{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp data.validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spliting data\n",
    "\n",
    "> Functions required to perform cross-validation and transform unique time series sequence into multiple samples ready to be used by a time series model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from tsai.imports import *\n",
    "from tsai.utils import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from sklearn.model_selection import train_test_split, KFold, StratifiedKFold\n",
    "from imblearn.over_sampling import RandomOverSampler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def check_overlap(a, b, c=None):\n",
    "    a = toarray(a)\n",
    "    b = toarray(b)\n",
    "    overlap_ab = np.isin(a, b)\n",
    "    if c is None:\n",
    "        if isinstance(overlap_ab[0], (list, L, np.ndarray, torch.Tensor)):  overlap_ab = overlap_ab[0] \n",
    "        if not any(overlap_ab): return False\n",
    "        else: return a[overlap_ab].tolist()\n",
    "    else:\n",
    "        c = toarray(c)\n",
    "        overlap_ac = np.isin(a, c)\n",
    "        if isinstance(overlap_ac[0], (list, L, np.ndarray, torch.Tensor)):  overlap_ac = overlap_ac[0] \n",
    "        overlap_bc = np.isin(b, c)\n",
    "        if isinstance(overlap_bc[0], (list, L, np.ndarray, torch.Tensor)):  overlap_bc = overlap_bc[0] \n",
    "        if not any(overlap_ab) and not any(overlap_ac) and not any(overlap_bc): return False\n",
    "        else: return a[overlap_ab].tolist(), a[overlap_ac].tolist(), b[overlap_bc].tolist()\n",
    "\n",
    "def check_splits_overlap(splits):\n",
    "    return [check_overlap(*_splits) for _splits in splits] if is_listy(splits[0][0]) else check_overlap(*splits)\n",
    "\n",
    "def leakage_finder(*splits, verbose=True):\n",
    "    '''You can pass splits as a tuple, or train, valid, ...'''\n",
    "    splits = L(*splits)\n",
    "    overlaps = 0\n",
    "    for i in range(len(splits)):\n",
    "        for j in range(i + 1, len(splits)):\n",
    "            overlap = check_overlap(splits[i], splits[j])\n",
    "            if overlap: \n",
    "                pv(f'overlap between splits [{i}, {j}] {overlap}', verbose)\n",
    "                overlaps += 1\n",
    "    assert overlaps == 0, 'Please, review your splits!'\n",
    "\n",
    "\n",
    "def balance_idx(o, shuffle=False, random_state=None, verbose=False):\n",
    "    if isinstance(o, list): o = L(o)\n",
    "    idx_ = np.arange(len(o)).reshape(-1, 1)\n",
    "    ros = RandomOverSampler(random_state=random_state)\n",
    "    resampled_idxs, _ = ros.fit_resample(idx_, np.asarray(o))\n",
    "    new_idx = L(resampled_idxs.reshape(-1,).tolist())\n",
    "    if shuffle: new_idx = random_shuffle(new_idx)\n",
    "    return new_idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10)\n",
    "b = np.arange(10, 20)\n",
    "test_eq(check_overlap(a, b), False)\n",
    "a = np.arange(10)\n",
    "b = np.arange(9, 20)\n",
    "test_eq(check_overlap(a, b), [9])\n",
    "a = np.arange(10)\n",
    "b = np.arange(10, 20)\n",
    "c = np.arange(20, 30)\n",
    "test_eq(check_overlap(a, b, c), False)\n",
    "a = np.arange(10)\n",
    "b = np.arange(10, 20)\n",
    "c = np.arange(10, 30)\n",
    "test_eq(check_overlap(a, b, c), ([], [], [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = L(list(concat(np.zeros(5), np.ones(10)).astype(int)))\n",
    "balanced_idx = balance_idx(l)\n",
    "test_eq(np.mean(l[balanced_idx]), 0.5)\n",
    "test_eq(isinstance(balanced_idx, L), True)\n",
    "\n",
    "l = list(concat(np.zeros(5), np.ones(10)).astype(int))\n",
    "balanced_idx = balance_idx(l)\n",
    "test_eq(np.mean(L(l)[balanced_idx]), 0.5)\n",
    "test_eq(isinstance(balanced_idx, L), True)\n",
    "\n",
    "a = concat(np.zeros(5), np.ones(10)).astype(int)\n",
    "balanced_idx = balance_idx(a)\n",
    "test_eq(np.mean(a[balanced_idx]), 0.5)\n",
    "test_eq(isinstance(balanced_idx, L), True)\n",
    "\n",
    "t = concat(torch.zeros(5), torch.ones(10))\n",
    "balanced_idx = balance_idx(t, shuffle=True)\n",
    "test_eq(t[balanced_idx].mean(), 0.5)\n",
    "test_eq(isinstance(balanced_idx, L), True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = np.arange(100_000), np.arange(100_000, 200_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soft_labels = True\n",
    "filter_pseudolabels = .5\n",
    "balanced_pseudolabels = True\n",
    "\n",
    "\n",
    "pseudolabels = torch.rand(1000, 3)\n",
    "pseudolabels = torch.softmax(pseudolabels, -1) if soft_labels else torch.argmax(pseudolabels, -1)\n",
    "hpl = torch.argmax(pseudolabels, -1) if soft_labels else pseudolabels\n",
    "\n",
    "if filter_pseudolabels and pseudolabels.ndim > 1: \n",
    "    error = 1 - pseudolabels.max(-1).values\n",
    "    filt_pl_idx = np.arange(len(error))[error < filter_pseudolabels]\n",
    "    filt_pl = pseudolabels[error < filter_pseudolabels]\n",
    "    assert len(filt_pl) > 0, 'no filtered pseudolabels'\n",
    "    filt_hpl = torch.argmax(filt_pl, -1)\n",
    "else: \n",
    "    filt_pl_idx = np.arange(len(pseudolabels))\n",
    "    filt_pl = filt_hpl = pseudolabels\n",
    "pl_split = filt_pl_idx[balance_idx(filt_hpl)] if balanced_pseudolabels else filt_pl_idx\n",
    "test_eq(hpl[pl_split].float().mean(), np.mean(np.unique(hpl)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def TrainValidTestSplitter(n_splits:int=1, valid_size:Union[float, int]=0.2, test_size:Union[float, int]=0., train_only:bool=False,\n",
    "                           stratify:bool=True, balance:bool=False, shuffle:bool=True, random_state:Union[None, int]=None, verbose:bool=False, **kwargs):\n",
    "    \"Split `items` into random train, valid (and test optional) subsets.\"\n",
    "    \n",
    "    if not shuffle and stratify and not train_only: \n",
    "        pv('stratify set to False because shuffle=False. If you want to stratify set shuffle=True', verbose)\n",
    "        stratify = False\n",
    "        \n",
    "    def _inner(o, **kwargs):\n",
    "        if stratify:\n",
    "            _, unique_counts = np.unique(o, return_counts=True)\n",
    "            if np.min(unique_counts) >= 2 and np.min(unique_counts) >= n_splits: stratify_ = stratify  \n",
    "            elif np.min(unique_counts) < n_splits: \n",
    "                stratify_ = False\n",
    "                pv(f'stratify set to False as n_splits={n_splits} cannot be greater than the min number of members in each class ({np.min(unique_counts)}).', \n",
    "                   verbose)\n",
    "            else:\n",
    "                stratify_ = False\n",
    "                pv('stratify set to False as the least populated class in o has only 1 member, which is too few.', verbose)\n",
    "        else: stratify_ = False\n",
    "        vs = 0 if train_only else 1. / n_splits if n_splits > 1 else int(valid_size * len(o)) if isinstance(valid_size, float) else valid_size\n",
    "        if test_size: \n",
    "            ts = int(test_size * len(o)) if isinstance(test_size, float) else test_size\n",
    "            train_valid, test = train_test_split(range(len(o)), test_size=ts, stratify=o if stratify_ else None, shuffle=shuffle, \n",
    "                                                 random_state=random_state, **kwargs)\n",
    "            test = toL(test)\n",
    "            if shuffle: test = random_shuffle(test, random_state)\n",
    "            if vs == 0:\n",
    "                train, _ = RandomSplitter(0, seed=random_state)(o[train_valid])\n",
    "                train = toL(train)\n",
    "                if balance: train = train[balance_idx(o[train], random_state=random_state)]\n",
    "                if shuffle: train = random_shuffle(train, random_state)\n",
    "                train_ = L(L([train]) * n_splits) if n_splits > 1 else train\n",
    "                valid_ = L(L([train]) * n_splits) if n_splits > 1 else train\n",
    "                test_ = L(L([test]) * n_splits) if n_splits > 1 else test\n",
    "                if n_splits > 1: \n",
    "                    return [split for split in itemify(train_, valid_, test_)]\n",
    "                else: \n",
    "                    return train_, valid_, test_\n",
    "            elif n_splits > 1: \n",
    "                if stratify_: \n",
    "                    splits = StratifiedKFold(n_splits=n_splits, shuffle=shuffle, random_state=random_state).split(np.arange(len(train_valid)), o[train_valid])\n",
    "                else:\n",
    "                    splits = KFold(n_splits=n_splits, shuffle=shuffle, random_state=random_state).split(np.arange(len(train_valid)))\n",
    "                train_, valid_ = L([]), L([])\n",
    "                for train, valid in splits:\n",
    "                    train, valid = toL(train), toL(valid)\n",
    "                    if balance: train = train[balance_idx(o[train], random_state=random_state)]\n",
    "                    if shuffle: \n",
    "                        train = random_shuffle(train, random_state)\n",
    "                        valid = random_shuffle(valid, random_state)\n",
    "                    train_.append(L(L(train_valid)[train]))\n",
    "                    valid_.append(L(L(train_valid)[valid]))\n",
    "                test_ = L(L([test]) * n_splits)\n",
    "                return [split for split in itemify(train_, valid_, test_)]\n",
    "            else:\n",
    "                train, valid = train_test_split(range(len(train_valid)), test_size=vs, random_state=random_state, \n",
    "                                                stratify=o[train_valid] if stratify_ else None, shuffle=shuffle, **kwargs)\n",
    "                train, valid = toL(train), toL(valid)\n",
    "                if balance: train = train[balance_idx(o[train], random_state=random_state)]\n",
    "                if shuffle: \n",
    "                    train = random_shuffle(train, random_state)\n",
    "                    valid = random_shuffle(valid, random_state)\n",
    "                return (L(L(train_valid)[train]), L(L(train_valid)[valid]),  test)\n",
    "        else: \n",
    "            if vs == 0:\n",
    "                train, _ = RandomSplitter(0, seed=random_state)(o)\n",
    "                train = toL(train)\n",
    "                if balance: train = train[balance_idx(o[train], random_state=random_state)]\n",
    "                if shuffle: train = random_shuffle(train, random_state)\n",
    "                train_ = L(L([train]) * n_splits) if n_splits > 1 else train\n",
    "                valid_ = L(L([train]) * n_splits) if n_splits > 1 else train\n",
    "                if n_splits > 1: \n",
    "                    return [split for split in itemify(train_, valid_)]\n",
    "                else: \n",
    "                    return (train_, valid_)\n",
    "            elif n_splits > 1: \n",
    "                if stratify_: splits = StratifiedKFold(n_splits=n_splits, shuffle=shuffle, random_state=random_state).split(np.arange(len(o)), o)\n",
    "                else: splits = KFold(n_splits=n_splits, shuffle=shuffle, random_state=random_state).split(np.arange(len(o)))\n",
    "                train_, valid_ = L([]), L([])\n",
    "                for train, valid in splits:\n",
    "                    train, valid = toL(train), toL(valid)\n",
    "                    if balance: train = train[balance_idx(o[train], random_state=random_state)]\n",
    "                    if shuffle: \n",
    "                        train = random_shuffle(train, random_state)\n",
    "                        valid = random_shuffle(valid, random_state)\n",
    "                    if not isinstance(train, (list, L)):  train = train.tolist()\n",
    "                    if not isinstance(valid, (list, L)):  valid = valid.tolist()\n",
    "                    train_.append(L(train))\n",
    "                    valid_.append(L(L(valid)))\n",
    "                return [split for split in itemify(train_, valid_)]\n",
    "            else:\n",
    "                train, valid = train_test_split(range(len(o)), test_size=vs, random_state=random_state, stratify=o if stratify_ else None, \n",
    "                                                shuffle=shuffle, **kwargs)\n",
    "                train, valid = toL(train), toL(valid)\n",
    "                if balance: train = train[balance_idx(o[train], random_state=random_state)]\n",
    "                return train, valid\n",
    "    return _inner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from matplotlib.patches import Patch\n",
    "\n",
    "def plot_splits(splits):\n",
    "    _max = 0\n",
    "    _splits = 0\n",
    "    for i, split in enumerate(splits):\n",
    "        if is_listy(split[0]):\n",
    "            for j, s in enumerate(split):\n",
    "                _max = max(_max, array(s).max())\n",
    "                _splits += 1\n",
    "        else: \n",
    "            _max = max(_max, array(split).max())\n",
    "            _splits += 1\n",
    "    _splits = [splits] if not is_listy(split[0]) else splits\n",
    "    v = np.zeros((len(_splits), _max + 1))\n",
    "    for i, split in enumerate(_splits):\n",
    "        if is_listy(split[0]):\n",
    "            for j, s in enumerate(split): \n",
    "                v[i, s] = 1 + j\n",
    "        else: v[i, split] = 1 + i\n",
    "    vals = np.unique(v)\n",
    "    plt.figure(figsize=(16, len(_splits)/2))\n",
    "    if len(vals) == 1:\n",
    "        v = np.ones((len(_splits), _max + 1))\n",
    "        plt.pcolormesh(v, color='blue')\n",
    "        legend_elements = [Patch(facecolor='blue', label='Train')]\n",
    "        plt.legend(handles=legend_elements, bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "    else: \n",
    "        colors = L(['gainsboro', 'blue', 'limegreen', 'red'])[vals]\n",
    "        cmap = matplotlib.colors.LinearSegmentedColormap.from_list('', colors)\n",
    "        plt.pcolormesh(v, cmap=cmap)\n",
    "        legend_elements = L([\n",
    "            Patch(facecolor='gainsboro', label='None'),\n",
    "            Patch(facecolor='blue', label='Train'),\n",
    "            Patch(facecolor='limegreen', label='Valid'),\n",
    "            Patch(facecolor='red', label='Test')])[vals]\n",
    "        plt.legend(handles=legend_elements, bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "    plt.title('Split distribution')\n",
    "    plt.yticks(ticks=np.arange(.5, len(_splits)+.5, 1.0), labels=np.arange(1, len(_splits)+1, 1.0).astype(int))\n",
    "    plt.gca().invert_yaxis()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def get_splits(o, n_splits:int=1, valid_size:float=0.2, test_size:float=0., train_only:bool=False, train_size:Union[None, float, int]=None, balance:bool=False,\n",
    "               shuffle:bool=True, stratify:bool=True, check_splits:bool=True, random_state:Union[None, int]=None, show_plot:bool=True, verbose:bool=False):\n",
    "    '''Arguments: \n",
    "        o            : object to which splits will be applied, usually target.\n",
    "        n_splits     : number of folds. Must be an int >= 1.\n",
    "        valid_size   : size of validation set. Only used if n_splits = 1. If n_splits > 1 valid_size = (1. - test_size) / n_splits. \n",
    "        test_size    : size of test set. Default = 0.\n",
    "        train_only   : if True valid set == train set. This may be useful for debugging purposes.\n",
    "        train_size   : size of the train set used. Default = None (the remainder after assigning both valid and test). \n",
    "                        Useful for to get learning curves with different train sizes or get a small batch to debug a neural net.\n",
    "        balance      : whether to balance data so that train always contain the same number of items per class.\n",
    "        shuffle      : whether to shuffle data before splitting into batches. Note that the samples within each split will be shuffle.\n",
    "        stratify     : whether to create folds preserving the percentage of samples for each class.\n",
    "        check_splits : whether to perform leakage and completion checks.\n",
    "        random_state : when shuffle is True, random_state affects the ordering of the indices. Pass an int for reproducible output.\n",
    "        show_plot    : plot the split distribution\n",
    "    '''\n",
    "    if n_splits == 1 and valid_size == 0. and  test_size == 0.: train_only = True\n",
    "    if balance: stratify = True\n",
    "    splits = TrainValidTestSplitter(n_splits, valid_size=valid_size, test_size=test_size, train_only=train_only, stratify=stratify, \n",
    "                                      balance=balance, shuffle=shuffle, random_state=random_state, verbose=verbose)(o)\n",
    "    if check_splits:\n",
    "        if train_only or (n_splits == 1 and valid_size == 0): print('valid == train')\n",
    "        elif n_splits > 1: \n",
    "            for i in range(n_splits): \n",
    "                leakage_finder([*splits[i]], verbose=True)\n",
    "                cum_len = 0\n",
    "                for split in splits[i]: cum_len += len(split)\n",
    "                if not balance: assert len(o) == cum_len, f'len(o)={len(o)} while cum_len={cum_len}'\n",
    "        else: \n",
    "            leakage_finder([splits], verbose=True)\n",
    "            cum_len = 0\n",
    "            if not isinstance(splits[0], Integral):\n",
    "                for split in splits: cum_len += len(split)\n",
    "            else: cum_len += len(splits)\n",
    "            if not balance: assert len(o) == cum_len, f'len(o)={len(o)} while cum_len={cum_len}'\n",
    "    if train_size is not None and train_size != 1: # train_size=1 legacy\n",
    "        if n_splits > 1:\n",
    "            splits = list(splits)\n",
    "            for i in range(n_splits): \n",
    "                splits[i] = list(splits[i])\n",
    "                if isinstance(train_size, Integral):\n",
    "                    n_train_samples = train_size  \n",
    "                elif train_size > 0 and train_size < 1: \n",
    "                    n_train_samples = int(len(splits[i][0]) * train_size)\n",
    "                splits[i][0] = L(np.random.choice(splits[i][0], n_train_samples, False).tolist())\n",
    "                if train_only:\n",
    "                    if valid_size != 0: splits[i][1] = splits[i][0]\n",
    "                    if test_size != 0: splits[i][2] = splits[i][0]\n",
    "                splits[i] = tuple(splits[i])\n",
    "            splits = tuple(splits)\n",
    "        else: \n",
    "            splits = list(splits)\n",
    "            if isinstance(train_size, Integral):\n",
    "                n_train_samples = train_size  \n",
    "            elif train_size > 0 and train_size < 1: \n",
    "                n_train_samples = int(len(splits[0]) * train_size)\n",
    "            splits[0] = L(np.random.choice(splits[0], n_train_samples, False).tolist())\n",
    "            if train_only:\n",
    "                if valid_size != 0: splits[1] = splits[0]\n",
    "                if test_size != 0: splits[2] = splits[0]\n",
    "            splits = tuple(splits)\n",
    "    if show_plot: plot_splits(splits)\n",
    "    return splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x180 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(((#5000) [6604,3593,8005,3280,3451,7846,7683,8649,2488,2368...],\n",
       "  (#1600) [5724,1035,6708,55,3895,4572,7917,3987,1512,811...],\n",
       "  (#2000) [3484,9724,1032,7164,6934,2149,1010,2235,1179,5839...]),\n",
       " ((#5000) [3086,3315,6721,7877,9760,3187,2010,1867,120,3832...],\n",
       "  (#1600) [8240,4340,7580,4992,9464,3075,6049,2176,8325,8951...],\n",
       "  (#2000) [3484,9724,1032,7164,6934,2149,1010,2235,1179,5839...]),\n",
       " ((#5000) [9715,259,340,8024,1834,4909,9869,8438,6025,8811...],\n",
       "  (#1600) [8361,6081,9440,5951,9876,9020,6283,5545,1074,5338...],\n",
       "  (#2000) [3484,9724,1032,7164,6934,2149,1010,2235,1179,5839...]),\n",
       " ((#5000) [3671,5261,4077,7380,8731,3912,5083,8868,1269,7901...],\n",
       "  (#1600) [5111,684,1589,6581,7984,9961,5955,991,3392,2214...],\n",
       "  (#2000) [3484,9724,1032,7164,6934,2149,1010,2235,1179,5839...]),\n",
       " ((#5000) [3858,8771,7805,6150,2978,2192,8660,8301,2458,5111...],\n",
       "  (#1600) [3778,7824,8854,8872,7255,5827,5182,9501,1835,4511...],\n",
       "  (#2000) [3484,9724,1032,7164,6934,2149,1010,2235,1179,5839...]))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_splits                = 5\n",
    "valid_size              = 0.2\n",
    "test_size               = 0.2\n",
    "train_only              = False  # set to True for debugging (valid = train)\n",
    "train_size              = 5000\n",
    "stratify                = True\n",
    "balance                 = True\n",
    "shuffle                 = True\n",
    "predefined_splits       = None\n",
    "show_plot               = True \n",
    "\n",
    "\n",
    "check_splits = True\n",
    "random_state = 23\n",
    "\n",
    "y = np.random.randint(0, 3, 10000) + 100\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, valid_size=valid_size, test_size=test_size, shuffle=shuffle, balance=balance, stratify=stratify,\n",
    "                    train_only=train_only, train_size=train_size, check_splits=check_splits, random_state=random_state, show_plot=show_plot, verbose=True)\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "valid == train\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABAgAAABKCAYAAAA2RmZuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAASQklEQVR4nO3df3RU5Z3H8c+XhIjWgkRigIClglFDLGKUHy61ij2uWrVLFaQFKV2QPZyebcWu9VfBFm3X3ePZ2tW6rWKVxZrVlZzV7UG3blWo7tFdIsVa+Y1WsAlJSIIiRAn57h9zB6fXufMjMzAJeb/O4TD33ud+n++deea5M0/ufcbcXQAAAAAAoG/rV+gEAAAAAABA4TFAAAAAAAAAGCAAAAAAAAAMEAAAAAAAADFAAAAAAAAAxAABAAAAAAAQAwQAgF7MzF40s/nB41lm9uscYo0yMzez4mD5GTP7ep7y/LyZbUpYftvMvpiP2EG8P5jZBfmKBwAA+iYGCAAABWVmU8zsf8xsj5m1mtnLZnZutnHc/ZfufnFCXDezMd3Ny90vdffl6cplUo+7/9bdT+tuLqH6HjGzO0Pxx7r7i/mIDwAA+q7iQicAAOi7zGygpF9JWijpCUklkj4v6cNC5pVPZlbs7p2FzgMAACAdriAAABRSpSS5e627H3T3/e7+a3d/XZLMbG5wRcF9wRUGG83somSBgrIvBY/XBKvXm9leM7smSfkiM7vbzFrMbLukL4W2J96+MMbMVgc5tJjZ41H1mNkFZrbTzG4ys0ZJD8fXhVI418zeNLM2M3vYzAaEjyMhFw9yWCBplqTvBvX9Z7D90C0LZnaMmd1jZn8K/t1jZscE2+K5fcfMmsyswcy+kfZVAgAAfQIDBACAQtos6aCZLTezS81scJIyEyVtkzRE0u2S6sysNFVQdz8/eDjO3Y9398eTFLtO0uWSxks6R9LVKULeIenXkgZLGiHp3jT1DJVUKukzkhZExJwl6S8ljVZsoOR7qY4pqO8BSb+U9I9BfVckKXabpEmSzpI0TtKEUOyhkgZJqpA0T9JPI553AADQxzBAAAAoGHd/T9IUSS7pQUnNZva0mZUnFGuSdI+7Hwi+gG9S6K/93TQjiLvD3Vsl/X2KsgcU+7I/3N073P2lFGUlqUvS7e7+obvvjyhzX0LdP5T01WwPIMIsSUvdvcndmyX9QNK1CdsPBNsPuPsqSXsl5WV+BAAA0LsxQAAAKCh33+Duc919hKRqScMl3ZNQ5F1394TlPwZlcjVc0o5Q3CjflWSS/jf4xYC/ThO72d070pQJ152PY1IQJ/FYwrF3h+ZE2Cfp+DzVDQAAejEGCAAAPYa7b5T0iGIDBXEVZmYJyydL+lMeqmuQNDIUNyqvRne/zt2HS/obSfen+eUCT7EtLlx3/Jg+kHRcfIOZDc0y9p8Uu9ohWWwAAIBIDBAAAArGzE4PJswbESyPVOxS+1cSip0k6Vtm1t/Mpks6Q9KqDMLvknRKiu1PBHFHBPfg35wiz+nxHCW1KfYlvSvDeqJ8M6i7VLF5A+LzF6yXNNbMzgomLvx+aL909dVK+p6ZlZnZEElLJD3ajfwAAEAfwwABAKCQ3ldsEsJXzewDxQYG3pD0nYQyr0o6VVKLYvfqX+3uuzOI/X1Jy82s3cxmJNn+oKT/UuwL+WuS6lLEOjfIca+kpyV92923Z1hPlMcUm/hwu2KTMN4pSe6+WdJSSf8taYuk8HwHD0mqCur7jyRx75S0VtLrkn4fHNudWeQFAAD6KPvz2zoBAOg5zGyupPnuPqXQuQAAABztuIIAAAAAAAAwQAAAAAAAALjFAAAAAAAAiCsIAAAAAACAGCAAAAAAAACSig9H0NLSUv9w6Ic6pSj6Z5q3H9z+Z9vjy+H12YiKmYvEGNsPxn7RKlnMqG2pjiuT/FIdU1TsdM9tPNd4vrnkmOz5CcdNFydxv/i+6Z6HxP1SxU33eoRjpIuZaT2ZbIvKKWpduhip8u5u++tuLlGve6Z5Ztq2M807XGdUnHz0Q+H46R6ne77SvR+687pkewzZ5Ja4XUr9Xsq0TKq2G9VmMtkvLtfzRDiPeMxs21mq8lF5dqdvTLd/NmW6+14JP0/xx8ni5tJ2M/msEdUWUr13k5UNx0jV/+V6vk11vOHcMo2fLM9sRR1zOF4u54aoWJmcS1O9/pl+XsnlHJXJOSZdPt3t87M9f+aaQ3ee46j3UeK6XM494c+bUeWicozq55PFS7c+074+1efUZHVk85ki6nWJqjNc774N+1rcvewTB4Je77AMEFRUVKhkeYmeGPREZJkZe2b82fb4cnh9NqJi5iIxxow9sZ+3ThYzaluq48okv1THFBU73XMbzzWeby45Jnt+wnHTxUncL75vuuchcb9UcdO9HuEY6WJmWk8m26JyilqXLkaqvLvb/rqbS9TrnmmembbtTPMO1xkVJx/9UDh+usfpnq9074fuvC7ZHkM2uSVul1K/lzItk6rtRrWZTPaLy/U8Ec4jHjPbdpaqfFSe3ekb0+2fTZnuvlfCz1P8cbK4ubTdTD5rRLWFVO/dZGXDMVL1f7meb1Mdbzi3TOMnyzNbUcccjpfLuSEqVibn0lSvf6afV3I5R2VyjkmXT3f7/GzPn7nm0J3nOOp9lLgul3NP+PNmVLmoHKP6+WTx0q3PtK9P9Tk1WR3ZfKaIel2i6gzX+1rNa3/8xEHgqMAtBgAAAAAAgAECAAAAAADAAAEAAAAAANBhmoMAAAAAAICerL6+/qTi4uJlkqrVN/543iXpjc7Ozvk1NTVNyQowQAAAAAAA6HOKi4uXDR069IyysrK2fv36eaHzOdy6urqsubm5qrGxcZmkK5OV6QujJAAAAAAAhFWXlZW91xcGBySpX79+XlZWtkexKyaSlzmC+QAAAAAA0FP06yuDA3HB8UaOAzBAAAAAAABAAZhZzXXXXTcivrxkyZLyG264YXih8kk7B4GZ/ULS5ZKa3D3yUgQAAAAAAHqrbdu21eQz3ujRo+vTlSkpKfFVq1YNbmhoaBw2bFhnPuvvjkyuIHhE0iWHOQ8AAAAAAPqUoqIinzNnTvOPfvSj8vC2TZs2lUyaNKmysrKyavLkyZVbtmwpkaSrrrpq1Ny5c0eOHz/+9BEjRpz58MMPD47vs3jx4vLq6uozKisrqxYtWpT1lQhpBwjcfY2k1mwDAwAAAACA1G688camurq60t27dxclrl+4cOHJs2bN2r158+Y3r7nmmt0LFy4cGd+2a9eu/mvXrt341FNPbbn99tsrJKmurm7g1q1bB7z++usbNmzY8Obvfve745555pnjs8klb3MQmNkCM1trZmtbWxlPAAAAAAAgndLS0q7p06fvvuuuu05KXL9u3bpPLViwoFWSFi5c2FpfX3/oy/6VV17ZXlRUpJqamo7du3f3l6Rnn3124Jo1awZWVVVVjR07tmrbtm0DNm7cOCCbXNLOQZApd39A0gOSdOaZZ/apmSABAAAAAOiuW265ZdfZZ59dNXPmzJZMyg8YMODQd253P/T/9ddf33DjjTdmFCMZfsUAAAAAAIACKi8vP3jFFVe0PfbYY0Pi68aPH//BsmXLBkvSz3/+89Jzzjlnb6oYl1566XsrVqwYsmfPnn6S9NZbb/V/9913s7oogAECAAAAAAAK7Lbbbmtsb28/9IX+Zz/72TsrVqwYUllZWVVbW3vi/fffvyPV/l/5ylfemz59euu55557emVlZdW0adNGt7e3F6XaJyyTnzmslXSBpCFmtlPS7e7+UDaVAAAAAADQk2Xys4T5tm/fvnXxxyNHjuzcv3//oeXKysqPXnnllc3hfVauXPl2VIzFixc3LV68uKm7+aQdIHD3r3Y3OAAAAAAA6B24xQAAAAAAADBAAAAAAAAAGCAAAAAAAABigAAAAAAAAIgBAgAAAAAAIAYIAAAAAAA44iZOnFi5cuXKgYnrli5detKsWbNOTlZ+woQJp61Zs+Y4SfrCF74wpqWlpShc5oYbbhi+ZMmS8u7mlPZnDgEAAAAAONrVvFZTk8949WfX16faPn369Nba2trSq6666r34upUrV5beddddO9PFXr169dZ85BjGFQQAAAAAABxh1157bdvzzz8/qKOjwyRp06ZNJU1NTf0fffTR0urq6jPGjBkzdtGiRcOT7VtRUXFmQ0NDsSTddNNNQ0eNGlVdU1Nz2pYtW47JJSdz91z2Tx7U7H1Jm/IeGDiyhkhqKXQSQB7QlnG0oC3jaEFbRm/3GXcvK3QSuVq/fv3b48aNO/RePNJXEEjShRdeOGbevHkts2fPbr/11luHtrS0FN9xxx0N5eXlBzs7O3Xeeeeddu+9974zceLE/RMmTDjt7rvv3nH++efvq6ioOHPt2rUbtm7dWjJv3rxR9fX1Gw8cOKCzzjqrau7cuc1Lly7dFVXn+vXrh4wbN25Usm2H6xaDTe5+zmGKDRwRZraWdoyjAW0ZRwvaMo4WtGUAcTNmzGh9/PHHB8+ePbu9rq6u9MEHH3x7+fLlpY888siQzs5Oa25u7r9+/foBEydO3J9s/xdeeOH4yy67rP3Tn/50lyRdfPHF7bnkwy0GAAAAAAAUwNe+9rX2l19+eeBLL710XEdHR7+ysrLO++67r3z16tWbN2/e/ObUqVP3dHR0HLHv7QwQAAAAAABQAIMGDeqaPHny+/Pnzx81bdq01ra2tqJjjz22q7S09OCOHTuKX3zxxUGp9p86dereVatWnbB3715ra2vr99xzz52QSz6H6xaDBw5TXOBIoh3jaEFbxtGCtoyjBW0ZwCEzZ85snTNnzuja2trt48eP76iurt43evTo6mHDhn1UU1OzN9W+U6ZM2Tdt2rTW6urqsSeeeOKBz33ucx/kksthmaQQAAAAAICeLDxJYV+RapJCbjEAAAAAAAD5HSAws0vMbJOZbTWzm/MZG8g3MxtpZi+Y2Ztm9gcz+3awvtTMnjOzLcH/g4P1Zmb/HLTv183s7MIeAfAxMysys3Vm9qtg+bNm9mrQXh83s5Jg/THB8tZg+6iCJg6EmNkJZvakmW00sw1mNpl+Gb2NmS0KPlu8YWa1ZjaAfhlAb5C3AQIzK5L0U0mXSqqS9FUzq8pXfOAw6JT0HXevkjRJ0jeDNnuzpN+4+6mSfhMsS7G2fWrwb4GkfznyKQORvi1pQ8LyP0j6sbuPkdQmaV6wfp6ktmD9j4NyQE/yE0nPuvvpksYp1q7pl9FrmFmFpG9JOsfdqyUVSZop+mUAvUA+ryCYIGmru293948k/ZukL+cxPpBX7t7g7q8Fj99X7ENohWLtdnlQbLmkvwoef1nSv3rMK5JOMLNhRzZr4JPMbISkL0laFiybpKmSngyKhNtxvH0/KemioDxQcGY2SNL5kh6SJHf/yN3bRb+M3qdY0rFmVizpOEkNol8GeqKurq6uPvV+C463K2p7PgcIKiTtSFjeGawDerzgcr7xkl6VVO7uDcGmRknlwWPaOHqqeyR9Vx939idKanf3zmA5sa0easfB9j1BeaAn+KykZkkPB7fMLDOzT4l+Gb2Iu78r6W5J7yg2MLBHUr3ol4Ge6I3m5uZBfWWQoKury5qbmwdJeiOqzOH6mUOg1zCz4yWtlHS9u7+XOGjv7m5m/NQHeiwzu1xSk7vXm9kFBU4HyFWxpLMl/a27v2pmP9HHtxNIol9GzxfMkfFlxQa82iX9u6RLCpkTgOQ6OzvnNzY2LmtsbKxW35jAv0vSG52dnfOjCuRzgOBdSSMTlkcE64Aey8z6KzY48Et3rwtW7zKzYe7eEFyq2hSsp42jJ/oLSVea2WWSBkgaqNg93CeYWXHw16jEthpvxzuDS18HSdp95NMGktopaae7vxosP6nYAAH9MnqTL0p6y92bJcnM6hTrq+mXgR6mpqamSdKVhc6jJ8nnKMn/STo1mKG1RLHJWJ7OY3wgr4L7+x6StMHd/ylh09OSvh48/rqkpxLWzwlmzZ4kaU/CJa9AQbj7Le4+wt1HKdbvPu/usyS9IOnqoFi4Hcfb99VBef4aix7B3Rsl7TCz04JVF0l6U/TL6F3ekTTJzI4LPmvE2zH9MoAez/LZ/wR/wbpHsdlaf+HuP8xbcCDPzGyKpN9K+r0+vnf7VsXmIXhC0smS/ihphru3Bif5+xS7THCfpG+4+9ojnjgQIbjF4O/c/XIzO0WxyWJLJa2TNNvdPzSzAZJWKDbnRqukme6+vUApA59gZmcpNuFmiaTtkr6h2B806JfRa5jZDyRdo9gvJq2TNF+xuQbolwH0aHkdIAAAAAAAAL1TX5iIAQAAAAAApMEAAQAAAAAAYIAAAAAAAAAwQAAAAAAAAMQAAQAAAAAAEAMEAAAAAABADBAAAAAAAAAxQAAAAAAAACT9Pze1SVphyRugAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "((#256) [935,502,884,723,796,339,996,579,638,15...],\n",
       " (#256) [935,502,884,723,796,339,996,579,638,15...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_size=256\n",
    "y = np.random.randint(0, 3, 1000) + 100\n",
    "splits = get_splits(y, train_size=train_size, train_only=True)\n",
    "test_eq(splits[0], splits[1])\n",
    "test_eq(len(splits[0]), train_size)\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def TSSplitter(valid_size:Union[int, float]=0.2, test_size:Union[int, float]=0., show_plot:bool=True):\n",
    "    \"Create function that splits `items` between train/val with `valid_size` without shuffling data.\"\n",
    "    def _inner(o):\n",
    "        valid_cut = valid_size if isinstance(valid_size, Integral) else int(round(valid_size * len(o)))\n",
    "        if test_size: \n",
    "            test_cut = test_size if isinstance(test_size, Integral) else int(round(test_size * len(o)))\n",
    "        idx = np.arange(len(o))\n",
    "        if test_size: \n",
    "            splits = L(idx[:-valid_cut - test_cut].tolist()), L(idx[-valid_cut - test_cut: - test_cut].tolist()), L(idx[-test_cut:].tolist())\n",
    "        else: \n",
    "            splits = L(idx[:-valid_cut].tolist()), L(idx[-valid_cut:].tolist())\n",
    "        if show_plot: \n",
    "            if len(o) > 1_000_000:\n",
    "                warnings.warn('the splits are too large to be plotted')\n",
    "            else: \n",
    "                plot_splits(splits)\n",
    "        return splits\n",
    "    return _inner\n",
    "\n",
    "TimeSplitter = TSSplitter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "((#800) [0,1,2,3,4,5,6,7,8,9...],\n",
       " (#200) [800,801,802,803,804,805,806,807,808,809...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.arange(1000) + 100\n",
    "test_eq(TimeSplitter(valid_size=0.2)(y)[1], L(np.arange(800, 1000).tolist()))\n",
    "test_eq(TimeSplitter(valid_size=0.2)(y)[0], TimeSplitter(valid_size=200)(y)[0])\n",
    "TimeSplitter(valid_size=0.2, show_plot=True)(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stratify set to False as n_splits=5 cannot be greater than the min number of members in each class (1).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x180 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(601.11, (#800) [314,194,782,789,502,917,137,415,904,181...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_splits                = 5\n",
    "valid_size              = 0.2  \n",
    "test_size               = 0\n",
    "train_only              = False  # set to True for debugging (valid = train)\n",
    "train_size              = None\n",
    "stratify                = True\n",
    "balance                 = True\n",
    "shuffle                 = True\n",
    "predefined_splits       = None\n",
    "show_plot               = True \n",
    "\n",
    "\n",
    "check_splits = True\n",
    "random_state = 23\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, valid_size=valid_size, test_size=test_size, shuffle=shuffle, balance=balance, stratify=stratify,\n",
    "                    train_only=train_only, train_size=train_size, check_splits=check_splits, random_state=random_state, show_plot=show_plot, verbose=True)\n",
    "split = splits[0] if n_splits == 1 else splits[0][0]\n",
    "y[split].mean(), split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[((#800) [314,194,782,789,502,917,137,415,904,181...],\n",
       "  (#200) [362,151,934,378,95,597,500,117,980,844...]),\n",
       " ((#800) [312,198,777,788,515,910,145,413,898,186...],\n",
       "  (#200) [352,133,955,396,64,596,442,79,991,882...]),\n",
       " ((#800) [311,197,783,791,507,922,145,416,908,184...],\n",
       "  (#200) [338,125,912,361,54,594,486,88,994,859...]),\n",
       " ((#800) [296,181,782,789,493,917,130,401,905,165...],\n",
       "  (#200) [405,199,953,444,113,610,515,137,997,881...]),\n",
       " ((#800) [320,190,782,788,506,906,141,412,893,178...],\n",
       "  (#200) [336,149,942,358,49,582,472,70,990,907...])]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list([splits[0], splits[1], splits[2], splits[3], splits[4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stratify set to False as n_splits=5 cannot be greater than the min number of members in each class (1).\n",
      "valid == train\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABAYAAAC3CAYAAACBg1waAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAATcElEQVR4nO3df7BnZX0f8Pdn966AYtQNqwRWi1GrS6hAXImdGERNiUYbO/7+EatGQsfJNKZawbSZ+qM4mXYyCW1NMxpAaGusjjFWmSRIEyyxjsRddA3yIxCKEWXdxQVBTWQv++kf37N6XXf33ovfe+/ee16vmTv3e8557nM+X3jm2ft933OeU90dAAAAYJzWrXQBAAAAwMoRDAAAAMCICQYAAABgxAQDAAAAMGKCAQAAABgxwQAAAACMmGAAgFWrqj5ZVecMr19VVZ/4Ifo6qaq6qmaG7T+pqtdMqc6fqaqb5mzfVlU/O42+h/6+WFVnTas/AGBcBAMArKiqenpVfbqqvlFVe6rq/1bVUxfbT3e/v7vPntNvV9XjH2hd3f3c7r5svnYLOU93/0V3P/GB1nLA+S6tqgsO6P8nuvuT0+gfABifmZUuAIDxqqofSXJ5kjck+VCSByX5mSTfWcm6pqmqZrp7dqXrAAA4FFcMALCS/mGSdPcHuvv+7v677v5Ed38hSarqtcMVBO8erii4saqefbCOhrafGl5fPezeUVXfrKqXHaT9+qr6raq6s6puTfK8A47PvU3h8VX1f4Ya7qyqDx7qPFV1VlXdXlXnV9XOJO/bv++AEp5aVddX1V1V9b6qOvrA9zGnlh5qODfJq5KcN5zv48Px796aUFVHVdWFVfXV4evCqjpqOLa/tjdX1a6quqOqXjfv/yUAYE0TDACwkv46yf1VdVlVPbeqHnGQNj+V5G+SHJfkbUk+UlUbD9dpd585vDy1u4/t7g8epNkvJ3l+ktOTbE3y4sN0+e+TfCLJI5JsTvJf5jnP8Uk2JvkHSc49RJ+vSvJzSR6XSUDyG4d7T8P53pvk/Un+43C+f3qQZv82ydOSnJbk1CRnHND38UkeluTEJK9P8ruH+O8OAIyEYACAFdPd9yR5epJO8vtJdlfVx6rqUXOa7UpyYXfvHT5435QD/rr/AL106PfL3b0nyW8epu3eTD7kn9Ddf9/dnzpM2yTZl+Rt3f2d7v67Q7R595xzvyvJKxb7Bg7hVUne2d27unt3knckefWc43uH43u7+4+TfDPJVNY/AABWJ8EAACuqu2/o7td29+YkpyQ5IcmFc5p8pbt7zvaXhjY/rBOSfPmAfg/lvCSV5C+HJwD80jx97+7uv5+nzYHnnsZ7ytDP3PdyYN9fP2DNg28nOXZK5wYAViHBAABHjO6+McmlmQQE+51YVTVn+zFJvjqF092R5NEH9HuounZ29y939wlJ/kWS/zrPkwj6MMf2O/Dc+9/Tt5I8eP+Bqjp+kX1/NZOrGw7WNwDADxAMALBiqupJw0J4m4ftR2dySf1n5jR7ZJJfraoNVfWSJFuS/PECuv9akh8/zPEPDf1uHu6xf+th6nzJ/hqT3JXJh/N9CzzPofzKcO6NmawLsH99gh1JfqKqThsWJHz7AT833/k+kOQ3qmpTVR2X5N8l+R8PoD4AYCQEAwCspHszWVzwmqr6ViaBwHVJ3jynzTVJnpDkzkzuxX9xd399AX2/PcllVXV3Vb30IMd/P8kVmXwQvzbJRw7T11OHGr+Z5GNJ3tjdty7wPIfyB5ksaHhrJosrXpAk3f3XSd6Z5H8nuTnJgesZXJzk5OF8Hz1Ivxck2ZbkC0n+anhvFyyiLgBgZOr7b9sEgCNHVb02yTnd/fSVrgUAYK1yxQAAAACMmGAAAAAARsytBAAAADBirhgAAACAERMMAAAAwIjNLEWnVcd1ctJSdA0AAMCK2n5nd29a6SqYniUJBiahwLal6RoAAIAVVF9a6QqYLrcSAAAAwIgJBgAAAGDEBAMAAAAwYku0xgAAAAAcubZv3/7ImZmZi5KckrX9R/N9Sa6bnZ095ylPecqugzUQDAAAADA6MzMzFx1//PFbNm3adNe6det6petZKvv27avdu3efvHPnzouS/MLB2qzlVAQAAAAO5ZRNmzbds5ZDgSRZt25db9q06RuZXBlx8DbLWA8AAAAcKdat9VBgv+F9HvLzv1sJAAAAYJnt3Llz/VlnnfXEJLnzzjs3rFu3rjdu3DibJJ///OdvOProow8ZWlx99dUPvuSSS3700ksv/fI0apk3GKiqS5I8P8mu7j7kpQcAAACwWlXlKdPsrzvbD3f8+OOPv//GG2+8Pkne9KY3nXDsscfe/853vvNr+4/v3bs3GzZsOOjPnnnmmd8+88wzvz2tWhdyK8GlSZ4zrRMCAAAAP+hFL3rRSa985Ssf8+QnP/lJb3jDGzZfddVVDz7ttNOetGXLlpNPP/30J+3YseOoJLn88ssf+sxnPvPxySRUeMlLXnLSGWec8cTNmzf/owsuuOCRiz3vvFcMdPfVVXXSot8RAAAAsCh33HHHg6699tobZ2ZmsmfPnnWf/exnb9ywYUM++tGPPvS8887bfMUVV/zNgT9zyy23HP3pT3/6prvvvnv9li1bTnnLW96y+6ijjlrw+glTW2Ogqs5Ncu5k6zHT6hYAAABG44UvfOFdMzOTj+p79uxZ/7KXveyxt91229FV1Xv37q2D/czZZ5999zHHHNPHHHPM7MaNG/fefvvtM4973OP2LvScU3sqQXe/t7u3dvfWZNO0ugUAAIDROPbYY/ftf33++eef+IxnPOPem2+++Ysf//jHb7nvvvsO+hl+7tUB69evz+zs7EEDhEPxuEIAAAA4At1zzz3rN2/efF+SvOc97zluqc4jGAAAAIAj0Pnnn7/z7W9/++YtW7acPDs7u2Tnqe7Dr0dQVR9IclaS45J8Lcnbuvviw//M1k62TatGAAAAjhi1fXIL+eq2Y8eO20499dQ7V7qO5bJjx47jTj311JMOdmwhTyV4xdQrAgAAAI4IbiUAAACAERMMAAAAwIgJBgAAABijffv27VvUY/1Wq+F97jvUccEAAAAAY3Td7t27H7bWw4F9+/bV7t27H5bkukO1mXfxQQAAAFhrZmdnz9m5c+dFO3fuPCVr+4/m+5JcNzs7e86hGsz7uMIHwuMKAQAA1qq18bhCvmctpyIAAADAPAQDAAAAMGKCAQAAABgxwQAAAACMmGAAAAAARkwwAAAAACMmGAAAAIAREwwAAADAiAkGAAAAYMQEAwAAADBiggEAAAAYMcEAAAAAjNi8wUBVPbqqrqqq66vqi1X1xuUoDAAAAFh6MwtoM5vkzd19bVU9NMn2qrqyu69f4toAAACAJTbvFQPdfUd3Xzu8vjfJDUlOXOrCAAAAgKW3qDUGquqkJKcnuWZJqgEAAACW1YKDgao6NskfJvm17r7nIMfPraptVbUt2T3NGgEAAIAlUt09f6OqDUkuT3JFd//2/O23drJtCuUBAABwZKnt3b11patgehbyVIJKcnGSGxYSCgAAAACrx0JuJfjpJK9O8qyq+vzw9fNLXBcAAACwDOZ9XGF3fypJLUMtAAAAwDJb1FMJAAAAgLVFMAAAAAAjJhgAAACAERMMAAAAwIgJBgAAAGDEBAMAAAAwYoIBAAAAGDHBAAAAAIyYYAAAAABGTDAAAAAAIyYYAAAAgBETDAAAAMCICQYAAABgxAQDAAAAMGKCAQAAABgxwQAAAACMmGAAAAAARkwwAAAAACM2bzBQVUdX1V9W1Y6q+mJVvWM5CgMAAACW3swC2nwnybO6+5tVtSHJp6rqT7r7M0tcGwAAALDE5g0GuruTfHPY3DB89VIWBQAAACyPBa0xUFXrq+rzSXYlubK7r1nSqgAAAIBlsaBgoLvv7+7TkmxOckZVnXJgm6o6t6q2VdW2ZPeUywQAAACWwqKeStDddye5KslzDnLsvd29tbu3JpumVB4AAACwlBbyVIJNVfXw4fUxSf5JkhuXuC4AAABgGSzkqQQ/luSyqlqfSZDwoe6+fGnLAgAAAJbDQp5K8IUkpy9DLQAAAMAyW9QaAwAAAMDaIhgAAACAERMMAAAAwIgJBgAAAGDEBAMAAAAwYoIBAAAAGDHBAAAAAIyYYAAAAABGTDAAAAAAIyYYAAAAgBETDAAAAMCICQYAAABgxAQDAAAAMGKCAQAAABgxwQAAAACMmGAAAAAARkwwAAAAACMmGAAAAIARW3AwUFXrq+pzVXX5UhYEAAAALJ/FXDHwxiQ3LFUhAAAAwPJbUDBQVZuTPC/JRUtbDgAAALCcFnrFwIVJzkuyb+lKAQAAAJbbvMFAVT0/ya7u3j5Pu3OraltVbUt2T61AAAAAYOlUdx++QdVvJnl1ktkkRyf5kSQf6e5fPPTPbO1k2zTrBAAA4IhQ27t760pXwfTMe8VAd/96d2/u7pOSvDzJnx8uFAAAAABWj8U8lQAAAABYY2YW07i7P5nkk0tSCQAAALDsXDEAAAAAIyYYAAAAgBETDAAAAMCICQYAAABgxAQDAAAAMGKCAQAAABgxwQAAAACMmGAAAAAARkwwAAAAACMmGAAAAIAREwwAAADAiAkGAAAAYMQEAwAAADBiggEAAAAYMcEAAAAAjJhgAAAAAEZMMAAAAAAjJhgAAACAERMMAAAAwIjNLKRRVd2W5N4k9yeZ7e6tS1kUAAAAsDwWFAwMntnddy5ZJQAAAMCycysBAAAAjNhCg4FO8omq2l5V5x6sQVWdW1Xbqmpbsnt6FQIAAABLprp7/kZVJ3b3V6rqkUmuTPIvu/vqQ7ff2sm2KZYJAADAkaG2W3dubVnQFQPd/ZXh+64kf5TkjKUsCgAAAFge8wYDVfWQqnro/tdJzk5y3VIXBgAAACy9hTyV4FFJ/qiq9rf/g+7+0yWtCgAAAFgW8wYD3X1rklOXoRYAAABgmXlcIQAAAIyYYAAAAABGTDAAAAAAIyYYAAAAgBETDAAAAMCICQYAAABgxAQDAAAAMGKCAQAAABix6u7pd1p1b5Kbpt4xLK/jkty50kXAFBjLrAXGMWuFscxa8MTufuhKF8H0zCxRvzd199Yl6huWRVVtM45ZC4xl1gLjmLXCWGYtqKptK10D0+VWAgAAABgxwQAAAACM2FIFA+9don5hORnHrBXGMmuBccxaYSyzFhjHa8ySLD4IAAAArA5uJQAAAIARm2owUFXPqaqbquqWqnrrNPuGaaqqR1fVVVV1fVV9sareOOzfWFVXVtXNw/dHDPurqv7zMLa/UFU/ubLvAL5fVa2vqs9V1eXD9mOr6pphzH6wqh407D9q2L5lOH7SihYOc1TVw6vqw1V1Y1XdUFX/2LzMalNV/2r43eK6qvpAVR1tTmY1qKpLqmpXVV03Z9+i5+Cqes3Q/uaqes1KvBcWb2rBQFWtT/K7SZ6b5OQkr6iqk6fVP0zZbJI3d/fJSZ6W5FeG8frWJH/W3U9I8mfDdjIZ108Yvs5N8nvLXzIc1huT3DBn+z8k+Z3ufnySu5K8ftj/+iR3Dft/Z2gHR4r/lORPu/tJSU7NZEybl1k1qurEJL+aZGt3n5JkfZKXx5zM6nBpkuccsG9Rc3BVbUzytiQ/leSMJG/bHyZwZJvmFQNnJLmlu2/t7vuS/M8kL5hi/zA13X1Hd187vL43k18+T8xkzF42NLssyT8bXr8gyX/ric8keXhV/djyVg0HV1WbkzwvyUXDdiV5VpIPD00OHMv7x/iHkzx7aA8rqqoeluTMJBcnSXff1913x7zM6jOT5Jiqmkny4CR3xJzMKtDdVyfZc8Duxc7BP5fkyu7e0913JbkyPxg2cASaZjBwYpIvz9m+fdgHR7Thsr3Tk1yT5FHdfcdwaGeSRw2vjW+OZBcmOS/JvmH7R5Pc3d2zw/bc8frdsTwc/8bQHlbaY5PsTvK+4baYi6rqITEvs4p091eS/FaSv80kEPhGku0xJ7N6LXYONjevUhYfZNSq6tgkf5jk17r7nrnHevLIDo/t4IhWVc9Psqu7t690LfBDmknyk0l+r7tPT/KtfO+S1STmZY58wyXTL8gk6DohyUPir6WsEebgtW2awcBXkjx6zvbmYR8ckapqQyahwPu7+yPD7q/tvxR1+L5r2G98c6T66SS/UFW3ZXIL17MyuU/74cNlrMn3j9fvjuXh+MOSfH05C4ZDuD3J7d19zbD94UyCAvMyq8nPJvl/3b27u/cm+Ugm87Q5mdVqsXOwuXmVmmYw8NkkTxhWXX1QJgutfGyK/cPUDPfvXZzkhu7+7TmHPpZk/+qpr0nyv+bs/+fDCqxPS/KNOZdVwYrp7l/v7s3dfVIm8+6fd/erklyV5MVDswPH8v4x/uKhvfSfFdfdO5N8uaqeOOx6dpLrY15mdfnbJE+rqgcPv2vsH8fmZFarxc7BVyQ5u6oeMVxBc/awjyNcTXPuqaqfz+Re1/VJLunud02tc5iiqnp6kr9I8lf53n3Z/yaTdQY+lOQxSb6U5KXdvWf4x/3dmVwO+O0kr+vubcteOBxGVZ2V5F939/Or6sczuYJgY5LPJfnF7v5OVR2d5L9nsq7GniQv7+5bV6hk+D5VdVomi2g+KMmtSV6XyR8xzMusGlX1jiQvy+QJSJ9Lck4m91ibkzmiVdUHkpyV5LgkX8vk6QIfzSLn4Kr6pUx+r06Sd3X3+5bxbfAATTUYAAAAAFYXiw8CAADAiAkGAAAAYMQEAwAAADBiggEAAAAYMcEAAAAAjJhgAAAAAEZMMAAAAAAjJhgAAACAEfv/67d5FCsrS2EAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1152x180 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 5\n",
    "valid_size = 0.\n",
    "test_size = 0.\n",
    "shuffle = True\n",
    "stratify = True\n",
    "train_only = True\n",
    "train_size = None\n",
    "check_splits = True\n",
    "random_state = 1\n",
    "show_plot = True \n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, valid_size=valid_size, test_size=test_size, shuffle=shuffle, stratify=stratify,\n",
    "                    train_only=train_only, train_size=train_size, check_splits=check_splits, random_state=random_state, show_plot=show_plot, verbose=True)\n",
    "for split in splits: \n",
    "    test_eq(len(split[0]), len(y))\n",
    "    test_eq(np.sort(split[0]), np.arange(len(y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x180 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x180 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 5\n",
    "y = np.random.randint(0, 2, 1000)\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, shuffle=False, check_splits=True)\n",
    "test_eq(np.concatenate((L(zip(*splits))[1])), np.arange(len(y)))\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, shuffle=True, check_splits=True)\n",
    "test_eq(np.sort(np.concatenate((L(zip(*splits))[1]))), np.arange(len(y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 2\n",
    "y = np.random.randint(0, 2, 1000)\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, test_size=0.2, shuffle=False)\n",
    "for i in range(n_splits): leakage_finder(*splits[i])\n",
    "test_eq(len(splits), n_splits)\n",
    "test_eq(len(splits[0]), 3)\n",
    "s = []\n",
    "[s.extend(split) for split in splits[0]]\n",
    "test_eq(np.sort(s), np.arange(len(y)))\n",
    "s = []\n",
    "[s.extend(split) for split in splits[1]]\n",
    "test_eq(np.sort(s), np.arange(len(y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = np.random.randint(0, 2, 1000)\n",
    "splits1 = get_splits(y, valid_size=.25, test_size=0, random_state=23, stratify=True, shuffle=True)\n",
    "splits2 = get_splits(y, valid_size=.25, test_size=0, random_state=23, stratify=True, shuffle=True)\n",
    "splits3 = get_splits(y, valid_size=.25, test_size=0, random_state=None, stratify=True, shuffle=True)\n",
    "splits4 = get_splits(y, valid_size=.25, test_size=0, random_state=None, stratify=True, shuffle=True)\n",
    "test_eq(splits1[0], splits2[0])\n",
    "test_ne(splits3[0], splits4[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = np.random.randint(0, 2, 100)\n",
    "splits = get_splits(y, valid_size=.25, test_size=0, random_state=23, stratify=True, shuffle=True)\n",
    "test_eq(len(splits), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = np.random.randint(0, 2, 100)\n",
    "splits = get_splits(y, valid_size=.25, test_size=0, random_state=23, stratify=True)\n",
    "test_eq(len(splits), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = np.random.randint(0, 2, 100)\n",
    "splits = get_splits(y, valid_size=.25, test_size=20, random_state=23, stratify=True)\n",
    "test_eq(len(splits), 3)\n",
    "leakage_finder(*splits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "splits = TrainValidTestSplitter(valid_size=.25, test_size=20, random_state=23, stratify=True)(np.random.randint(0, 2, 100))\n",
    "test_eq(len(splits[1]), 25)\n",
    "test_eq(len(splits[2]), 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABAYAAABKCAYAAAAoj1bdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAASDUlEQVR4nO3df3RUZX7H8c83CT8LopEIkmjjgovBKD+ioJYFRA+rLtX6A3+BvxbWHs+erlWrWLtHXcRT2+NxXWXboyJCq6VY4Vj12KpdEVY9ayUqLgoIS1lBE0lMIiAiGfLtH3OD4ziT+ZGbTDLzfp0zh7nPfe7zfO+dZ55hvrn3jrm7AAAAAABAYSrKdQAAAAAAACB3SAwAAAAAAFDASAwAAAAAAFDASAwAAAAAAFDASAwAAAAAAFDASAwAAAAAAFDASAwAAHotM3vNzOYFz2eb2cudaKvSzNzMSoLl/zKza0KK8wdmtjlmebuZnR1G20F7H5jZtLDaAwAAhYXEAAAgp8xsspm9aWZfmFmTmb1hZqdm2o67P+XuM2LadTMblW1c7n6uuy9LVS+dftz9t+4+OttY4vpbamYL49o/0d1fC6N9AABQeEpyHQAAoHCZ2WGSXpB0g6SnJfWV9ANJX+cyrjCZWYm7R3IdBwAAQDKcMQAAyKXvS5K7L3f3g+7+lbu/7O7vS5KZXRucQbAoOKNgk5mdlaihoO7rwfO1QfF6M9trZpclqF9sZvebWaOZbZP0o7j1sZcpjDKzNUEMjWa2Ilk/ZjbNzHaa2Xwzq5f0RHtZXAinmtmHZtZsZk+YWf/4/YiJxYMYrpc0W9JtQX/PB+sPXZpgZv3M7EEz+zR4PGhm/YJ17bHdYma7zKzOzK5L+SoBAIC8RmIAAJBLH0k6aGbLzOxcMzsiQZ1Jkv4gaaikuyStMrPSjhp19ynB07HuPsjdVySo9hNJMyWNl3SKpEs6aPIeSS9LOkJShaSHU/QzXFKppD+VdH2SNmdL+qGkkYomSH7e0T4F/T0q6SlJ/xj09+cJqv2dpNMkjZM0VtLEuLaHSxoiqVzSXEm/TnLcAQBAgSAxAADIGXffLWmyJJf0mKQGM3vOzIbFVNsl6UF3bw2+eG9W3F/3s3Rp0O4Od2+S9Pcd1G1V9Ev+CHff7+6vd1BXktok3eXuX7v7V0nqLIrp+15JV2S6A0nMlrTA3Xe5e4OkX0i6KmZ9a7C+1d1flLRXUij3PwAAAL0TiQEAQE65+0Z3v9bdKyRVSxoh6cGYKp+4u8cs/zGo01kjJO2IazeZ2ySZpP8NfgHgxynabnD3/SnqxPcdxj4paCd2X+Lb/jzungf7JA0KqW8AANALkRgAAPQY7r5J0lJFEwTtys3MYpaPlfRpCN3VSTomrt1kcdW7+0/cfYSkv5T0Tyl+icA7WNcuvu/2ffpS0sD2FWY2PMO2P1X07IZEbQMAAHwHiQEAQM6Y2QnBjfAqguVjFD2l/ncx1Y6S9DMz62NmsyRVSXoxjeY/k/S9DtY/HbRbEVxjf3sHcc5qj1FSs6JfztvS7CeZnwZ9lyp6X4D2+xOsl3SimY0Lbkh4d9x2qfpbLunnZlZmZkMl3SnpySziAwAABYLEAAAgl/YoenPBt8zsS0UTAhsk3RJT5y1Jx0tqVPRa/Evc/fM02r5b0jIzazGzSxOsf0zSS4p+EX9H0qoO2jo1iHGvpOck3eju29LsJ5l/U/SGhtsUvbniQkly948kLZD0P5K2SIq/n8HjksYE/T2boN2FktZJel/S74N9W5hBXAAAoMDYty/bBACg5zCzayXNc/fJuY4FAAAgX3HGAAAAAAAABYzEAAAAAAAABYxLCQAAAAAAKGCcMQAAAAAAQAEjMQAAAAAAQAEr6YpGzYa6VKmBVRu1b2PVofKBVRsPPY8tT0d8W8nKUq3raJvObB9bnmy/k5WlUz/VulR9pCtZXB3Fm6lM48qmv45ep3bJXq+wZTrmwownjGMdf8wyeQ90Zp/CHNOd3f9E74N04unsPJTJdonmkWyOU7Ljnu2YTLVtouMb3398/UTr0xkbHY3vTOb1TMZmstels++XVHXTmctTHZf48dDR51ymMm2rs5/dHa3LtP8w5uhs3q/ZzH/p9h9b1tm5JJ0+0/msSbZ9qjk57M/RdPYh2Xu4s/Fk83/O2DrtMpkXs/lc6+o4M31fp5rzwugjHV31XkrVV+wxbRfW/n/79drX6O5l2caMHsjdQ39INS65T6id4JIfekyonXDoEVueziPRNh21k2xdun1nun1sebL9TlaWTv1U61L1kclxThRXR/Fm81pm0kZY4yXZGOzs/oQVf1jHN+xjHX/MMnkPdGafwhzTnd3/ZP2niqez81Am2yU6Vtm0ney4ZxNvOtsmOp6p9jPdOTDd1zfTeT2TsZnsWHb2/ZLO+zHVXJ7quKRqJ9sxkU1bnf3sTnWswo430zjTjSGsz4dUr3k2x76zxzDV+z+d8dwVn6Pp7EOy93Bn48l0bsrkeCbbPpvPta6OszPxpPu+ybb/TI9tZ8Zfun3FHtOw9//bbWpdV3yP5JG7B5cSAAAAAABQwEgMAAAAAABQwEgMAAAAAABQwLrk5oMAAAAAAPRktbW1R5WUlCyWVK38/qN5m6QNkUhkXk1Nza5EFUgMAAAAAAAKTklJyeLhw4dXlZWVNRcVFXmu4+kqbW1t1tDQMKa+vn6xpPMT1cnnrAgAAAAAAMlUl5WV7c7npIAkFRUVeVlZ2ReKnhmRuE43xgMAAAAAQE9RlO9JgXbBfib9/s+lBAAAAAAAdLP6+vriadOmjZakxsbGPkVFRV5aWhqRpPfee29j//79kyYt1q5dO3DJkiVHLl26dEcYsaRMDJjZEkkzJe1y96SnHgAAAAAA0FuZqSbM9txV29H64cOHH9y0adOHknTzzTePGDRo0MEFCxZ81r6+tbVVffr0SbjtlClT9k2ZMmVfWLGmcynBUknnhNUhAAAAAAD4rosvvrjyyiuvPPbkk08+4YYbbqhYvXr1wHHjxp1QVVU1Zvz48SesX7++nyS98MILg88888xRUjSpMGvWrMqJEyeOrqioOGnhwoVHZdpvyjMG3H2tmVVmvEcAAAAAACAjdXV1fd95551NJSUlampqKnr77bc39enTR88+++zg2267reKll176Q/w2W7du7f/mm29ubmlpKa6qqqq+9dZbG/r165f2/RNCu8eAmV0v6fro0rFhNQsAAAAAQMG46KKLmktKol/Vm5qaii+77LLjtm/f3t/MvLW11RJtM2PGjJYBAwb4gAEDIqWlpa07d+4sGTlyZGu6fYb2qwTu/qi7n+Lup0hlYTULAAAAAEDBGDRoUFv78/nz55dPnTp1z5YtWz54/vnntx44cCDhd/jYswOKi4sViUQSJhCS4ecKAQAAAADogXbv3l1cUVFxQJIeeeSRoV3VD4kBAAAAAAB6oPnz59fffffdFVVVVWMikUiX9ZPOzxUulzRN0lAz2ynpLnd/vMsiAgAAAACgm6X6ecGu9MADD3yaqPzss8/+cvv27Rvalx966KFPJWnmzJl7Zs6cuSfRtlu2bPkg0/7T+VWCKzJtFAAAAAAA9A5cSgAAAAAAQAEjMQAAAAAAQAEjMQAAAAAAQAEjMQAAAAAAQAEjMQAAAAAAQAEjMQAAAAAAQDebNGnS91euXHlYbNmCBQuOmj179rGJ6k+cOHH02rVrB0rS1KlTRzU2NhbH17n55ptH3HnnncMyjSXlzxUCAAAAAJDvat6pqQmzvdoJtbUdrZ81a1bT8uXLSy+++OLd7WUrV64sve+++3amanvNmjVbw4ixHWcMAAAAAADQza666qrmV199dcj+/ftNkjZv3tx3165dfZ588snS6urqqlGjRp140003jUi0bXl5+Ul1dXUlkjR//vzhlZWV1TU1NaO3bNnSL5tYzN2z35NkjZrtkbQ59IaB7jVUUmOugwBCwFhGPmAcI18wlpEPRrv74FwH0Vnr16/fPnbs2EPvx+4+Y0CSzjzzzFFz585tnDNnTssdd9wxvLGxseSee+6pGzZs2MFIJKIzzjhj9MMPP/zxpEmTvpo4ceLo+++/f8eUKVP2lZeXn7Ru3bqNW7du7Tt37tzK2traTa2trRo3btyYa6+9tmHBggWfJdjfoWPHjq1MFEdXXUqw2d1P6aK2gW5hZusYx8gHjGXkA8Yx8gVjGfnAzNblOoZ8cemllzatWLHiiDlz5rSsWrWq9LHHHtu+bNmy0qVLlw6NRCLW0NDQZ/369f0nTZr0VaLtV69ePei8885rGTx4cJskzZgxoyWbOLiUAAAAAACAHLjyyitb3njjjcNef/31gfv37y8qKyuLLFq0aNiaNWs++uijjz6cPn36F/v37+/y7+0kBgAAAAAAyIEhQ4a0nX766XvmzZtXeeGFFzY1NzcXDxgwoK20tPTgjh07Sl577bUhHW0/ffr0vS+++OLhe/futebm5qJXXnnl8Gzi6KpLCR7tonaB7sQ4Rr5gLCMfMI6RLxjLyAeM4xBdfvnlTVdfffXI5cuXbxs/fvz+6urqfSNHjqw++uijD9TU1OztaNvJkyfvu/DCC5uqq6tPPPLII1tPPvnkL7OJoUtuPggAAAAAQE8Wf/PBfNfRzQe5lAAAAAAAgAIWamLAzM4xs81mttXMbg+zbSBMZnaMma02sw/N7AMzuzEoLzWzV8xsS/DvEUG5mdlDwdh+38wm5HYPgG8zs2Ize9fMXgiWjzOzt4Ixu8LM+gbl/YLlrcH6ypwGDsQws8PN7Bkz22RmG83sdOZl9DZmdlPwf4sNZrbczPozJ6M3MLMlZrbLzDbElGU8B5vZNUH9LWZ2TS72BZkLLTFgZsWSfi3pXEljJF1hZmPCah8IWUTSLe4+RtJpkn4ajNfbJf3G3Y+X9JtgWYqO6+ODx/WS/rn7QwY6dKOkjTHL/yDpl+4+SlKzpLlB+VxJzUH5L4N6QE/xK0n/7e4nSBqr6JhmXkavYWblkn4m6RR3r5ZULOlyMSejd1gq6Zy4sozmYDMrlXSXpEmSJkq6qz2ZgJ4tzDMGJkra6u7b3P2ApH+XdEGI7QOhcfc6d38neL5H0f98lis6ZpcF1ZZJ+ovg+QWS/sWjfifpcDM7unujBhIzswpJP5K0OFg2SdMlPRNUiR/L7WP8GUlnBfWBnDKzIZKmSHpcktz9gLu3iHkZvU+JpAFmViJpoKQ6MSejF3D3tZKa4ooznYN/KOkVd29y92ZJr+i7yYaepK2tra0g3nPBfrYlWx9mYqBc0o6Y5Z1BGdCjBaftjZf0lqRh7l4XrKqXNCx4zvhGT/agpNv0zWR/pKQWd48Ey7Hj9dBYDtZ/EdQHcu04SQ2Snggui1lsZn8i5mX0Iu7+iaT7JX2saELgC0m1Yk5G75XpHNzb5uYNDQ0NQ/I9OdDW1mYNDQ1DJG1IVqerfq4Q6BXMbJCklZL+2t13xybp3d3NjJ/tQI9mZjMl7XL3WjObluNwgM4okTRB0l+5+1tm9it9c8qqJOZl9HzBKdMXKJroapH0H+rZfy0F0paPc3AkEplXX1+/uL6+vlr5fWP+NkkbIpHIvGQVwkwMfCLpmJjliqAM6JHMrI+iSYGn3H1VUPyZmR3t7nXB6VC7gnLGN3qqP5N0vpmdJ6m/pMMUvU77cDMrCf4CFTte28fyzuA01yGSPu/+sIHv2Clpp7u/FSw/o2higHkZvcnZkv7P3RskycxWKTpPMyejt8p0Dv5E0rS48te6Ic6s1NTU7JJ0fq7j6AnCzIq8Len44K6rfRW90cpzIbYPhCa4fu9xSRvd/YGYVc9Jar976jWS/jOm/OrgDqynSfoi5rQqIGfc/W/dvcLdKxWdd19199mSVku6JKgWP5bbx/glQf28yv6jd3L3ekk7zGx0UHSWpA/FvIze5WNJp5nZwOD/Gu3jmDkZvVWmc/BLkmaY2RHBGTQzgjL0cBbm3BP8xepBRe/AusTd7w2tcSBEZjZZ0m8l/V7fXJd9h6L3GXha0rGS/ijpUndvCj7cFyl6OuA+Sde5+7puDxzoQHApwd+4+0wz+56iN4EtlfSupDnu/rWZ9Zf0r4reV6NJ0uXuvi1HIQPfYmbjFL2JZl9J2yRdp+gfMZiX0WuY2S8kXaboLyC9K2meotdYMyejRzOz5Yr+tX+opM8U/XWBZ5XhHGxmP1b0/9WSdK+7P9GNu4EshZoYAAAAAAAAvUs+32ABAAAAAACkQGIAAAAAAIACRmIAAAAAAIACRmIAAAAAAIACRmIAAAAAAIACRmIAAAAAAIACRmIAAAAAAIACRmIAAAAAAIAC9v+pBMZc6m30DQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "o = np.random.randint(0, 2, 1000)\n",
    "for p in [1, .75, .5, .25, .125]:\n",
    "    splits = get_splits(o, train_size=p)\n",
    "    test_eq(len(splits[0]), len(o) * .8 * p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABAYAAABTCAYAAAAMVgWOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAS7klEQVR4nO3df3RU5Z3H8c83CUIwiMYEEKKLBQkJKQGDUFuKSJWtFuxSilrQtrul7nHbbVe6FXu2x7rI7rp7PK7r6raKP8Cji1ag/sDfVgTULSthiSIQgy4UlEjSEH4KZJLv/jE3PdmYZIZ4M5OZeb/OySH33mee5/vMfeZh7jf3h7m7AAAAAABAZspKdgAAAAAAACB5SAwAAAAAAJDBSAwAAAAAAJDBSAwAAAAAAJDBSAwAAAAAAJDBSAwAAAAAAJDBSAwAAFKWmb1mZvOD3+eZ2Uufoa7hZuZmlhMsP29m3wkpzi+bWXWb5Z1mdkkYdQf1vWtmU8OqDwAAZBYSAwCApDKzyWb2ppkdMLMGM3vDzC442Xrc/VF3n96mXjezkd2Ny90vc/dlscrF0467r3f34u7G0q69pWa2uF39Y9z9tTDqBwAAmScn2QEAADKXmZ0mabWk6yX9WtIpkr4s6Xgy4wqTmeW4eyTZcQAAAHSGMwYAAMk0SpLcfbm7N7v7J+7+kru/LUlm9t3gDIK7gzMKtpvZVzqqKCj7evD7umB1lZkdNrOrOiifbWa3m1m9mX0g6Wvttre9TGGkma0NYqg3s8c7a8fMpprZHjNbaGa1kh5qXdcuhAvMbKuZ7Tezh8ysX/t+tInFgxiukzRP0o1Be88E2/94aYKZ9TWzO83so+DnTjPrG2xrje0nZrbPzPaa2Z/H3EsAACCtkRgAACTTe5KazWyZmV1mZmd0UGaSpPclFUj6haRVZpbfVaXuPiX4tdzd89z98Q6KfV/SDEnjJU2Q9M0uqrxV0kuSzpBUJOnfY7QzRFK+pD+RdF0ndc6T9KeSRiiaIPl5V30K2rtP0qOS/iVob2YHxf5O0hckjZNULmliu7qHSBooaZik70m6p5P3HQAAZAgSAwCApHH3g5ImS3JJSyTVmdnTZja4TbF9ku5096bgwLta7f66301XBvXudvcGSf/URdkmRQ/yh7r7MXd/vYuyktQi6RfuftzdP+mkzN1t2v4HSd862Q50Yp6kRe6+z93rJP29pGvbbG8Ktje5+3OSDksK5f4HAAAgNZEYAAAklbtvc/fvunuRpDJJQyXd2abIh+7ubZZ3BWU+q6GSdrertzM3SjJJ/x08AeAvYtRd5+7HYpRp33YYfVJQT9u+tK/7D+3ueXBUUl5IbQMAgBREYgAA0Gu4+3ZJSxVNELQaZmbWZvkcSR+F0NxeSWe3q7ezuGrd/fvuPlTSX0r6jxhPIvAutrVq33Zrn45I6t+6wcyGnGTdHyl6dkNHdQMAAHwKiQEAQNKY2ejgRnhFwfLZip5S/7s2xQZJ+pGZ9TGzOZJKJD0XR/UfS/pcF9t/HdRbFFxjf1MXcc5pjVHSfkUPzlvibKczPwjazlf0vgCt9yeokjTGzMYFNyS8pd3rYrW3XNLPzazQzAok3SzpkW7EBwAAMgSJAQBAMh1S9OaCG8zsiKIJgS2SftKmzAZJ50mqV/Ra/G+6+x/iqPsWScvMrNHMruxg+xJJLyp6IL5J0qou6rogiPGwpKcl/djdP4iznc78p6I3NPxA0ZsrLpYkd39P0iJJr0iqkdT+fgYPSCoN2nuyg3oXS9oo6W1J7wR9W3wScQEAgAxj//+yTQAAeg8z+66k+e4+OdmxAAAApCvOGAAAAAAAIIORGAAAAAAAIINxKQEAAAAAABmMMwYAAAAAAMhgJAYAAAAAAMhgOT1RqVmBS8O7LFOhyi63V6oixIi61r9kW8wyR7eVJCCSqFjvTby2lfSPWaZk29FQ2gpjf4W1H8KqJ579EE+/46knnn2VyL4nSqrFG694+pXIz146vs+J/FwlUlhjJ5H/hyZKWPs8ke9fWPuzN43ldB2jva1fvWmOC+v7UFji2VfxSOR3wbAk6jtufH2qrHf3wjgKIkX0yD0GzCZ49BHKnXNZ13Uocfc+qNgYe/BXTgjnYD0esd6beE3YeH7MMhsnbAqlrTD2V1j7Iax64tkP8fQ7nnri2VeJ7HuipFq88YqnX4n87KXj+5zIz1UihTV2Evl/aKKEtc8T+f6FtT9701hO1zHa2/rVm+a4sL4PhSWefRWPRH4XDEuivuPG1yerdPcJcRREiuBSAgAAAAAAMhiJAQAAAAAAMhiJAQAAAAAAMliP3HwQAAAAAIDerLKyclBOTs79ksqU3n80b5G0JRKJzK+oqNjXUQESAwAAAACAjJOTk3P/kCFDSgoLC/dnZWX1rruihqilpcXq6upKa2tr75d0RUdl0jkrAgAAAABAZ8oKCwsPpnNSQJKysrK8sLDwgKJnRnRcJoHxAAAAAADQW2Sle1KgVdDPTo//uZQAAAAAAIAEq62tzZ46dWqxJNXX1/fJysry/Pz8iCRt3rx5W79+/TpNWqxbt67/gw8+eObSpUt3hxFLzMSAmT0oaYakfe7e6akHAAAAAACkKjNVhFmfuyq72j5kyJDm7du3b5WkBQsWDM3Ly2tetGjRx63bm5qa1KdPnw5fO2XKlKNTpkw5Glas8VxKsFTSV8NqEAAAAAAAfNrs2bOHz50795yxY8eOvv7664vWrFnTf9y4caNLSkpKx48fP7qqqqqvJK1evXrAxRdfPFKKJhXmzJkzfOLEicVFRUWfX7x48aCTbTfmGQPuvs7Mhp90jwAAAAAAwEnZu3fvKZs2bdqek5OjhoaGrLfeemt7nz599OSTTw648cYbi1588cX3279mx44d/d58883qxsbG7JKSkrKf/vSndX379o37/gmh3WPAzK6TdF106ZywqgUAAAAAIGN84xvf2J+TEz1Ub2hoyL7qqqvO3blzZz8z86amJuvoNdOnT2/Mzc313NzcSH5+ftOePXtyRowY0RRvm6E9lcDd73P3Ce4+QSoMq1oAAAAAADJGXl5eS+vvCxcuHHbRRRcdqqmpefeZZ57ZceLEiQ6P4dueHZCdna1IJNJhAqEzPK4QAAAAAIBe6ODBg9lFRUUnJOnee+8t6Kl2SAwAAAAAANALLVy4sPaWW24pKikpKY1EIj3WTjyPK1wuaaqkAjPbI+kX7v5Aj0UEAAAAAECCxXq8YE+64447Pupo/SWXXHJk586dW1qX77rrro8kacaMGYdmzJhxqKPX1tTUvHuy7cfzVIJvnWylAAAAAAAgNXApAQAAAAAAGYzEAAAAAAAAGYzEAAAAAAAAGYzEAAAAAAAAGYzEAAAAAAAAGYzEAAAAAAAACTZp0qRRK1euPK3tukWLFg2aN2/eOR2VnzhxYvG6dev6S9JFF100sr6+Prt9mQULFgy9+eabB59sLDEfVwgAAAAAQLqr2FRREWZ9ledXVna1fc6cOQ3Lly/Pnz179sHWdStXrsy/7bbb9sSqe+3atTvCiLEVZwwAAAAAAJBg11577f5XX3114LFjx0ySqqurT9m3b1+fRx55JL+srKxk5MiRY2644YahHb122LBhn9+7d2+OJC1cuHDI8OHDyyoqKopramr6dieWHjpjoPKwZNVdlbCYdcQuEZbKCfGUSlw8obU0YVPi2gqhprD2Q1j1mFQgqT6EemKLY18lsu+JkmrxxiuefiXys1c5IZyx3Jsk8nOVSOGNnd7VrzDENSeH9v9eOO9faPuzF43ldB2jCe5XzLHcm8ZFb9uf8X13iEdYRyO9re9h9CuuPhXHUwhdGzx4cHN5efmRFStWDLzmmmsaly1blj9z5sz9t956697Bgwc3RyIRffGLXyzesGFD7qRJkz7pqI7169f3/81vfpP/zjvvbG1qatK4ceNKx48ff/RkY+mpSwmq3T20jy2QDGa2kXGMdMBYRjpgHCNdMJaRDsxsY7JjSBdXXnllw+OPP37GNddc07hq1ar8JUuW7Fy2bFn+0qVLCyKRiNXV1fWpqqrq11liYM2aNXmXX35544ABA1okafr06Y3diYNLCQAAAAAASIK5c+c2vvHGG6e9/vrr/Y8dO5ZVWFgYufvuuwevXbv2vffee2/rtGnTDhw7dqzHj9tJDAAAAAAAkAQDBw5sufDCCw/Nnz9/+KxZsxr279+fnZub25Kfn9+8e/funNdee21gV6+fNm3a4eeee+70w4cP2/79+7Nefvnl07sTR09dSnBfD9ULJBLjGOmCsYx0wDhGumAsIx0wjkN09dVXN3z7298esXz58g/Gjx9/rKys7OiIESPKzjrrrBMVFRWHu3rt5MmTj86aNauhrKxszJlnntk0duzYI92Jwdy9e9EDAAAAAJCiqqqqdpaXl8e4QXP6qKqqKigvLx/e0TYuJQAAAAAAIIOFmhgws6+aWbWZ7TCzm8KsG+hJZna2ma0xs61m9q6Z/ThYn29mL5tZTfDvGcmOFYjFzLLN7H/MbHWwfK6ZbQjm5sfN7JRkxwjEYmanm9kKM9tuZtvM7ELmZKQaM7sh+F6xxcyWm1k/5mSkAjN70Mz2mdmWNus6nIMt6q5gTL9tZucnL3J0V2iJATPLlnSPpMsklUr6lpmVhlU/0MMikn7i7qWSviDpB8H4vUnSb939PEm/DZaB3u7Hkra1Wf5nSf/q7iMl7Zf0vaREBZycf5P0gruPllSu6JhmTkbKMLNhkn4kaYK7l0nKlnS1mJORGpZK+mq7dZ3NwZdJOi/4uU7SLxMUI0IU5hkDEyXtcPcP3P2EpMckfT3E+oEe4+573X1T8PshRb+ADlN0DC8Lii2T9GdJCRCIk5kVSfqapPuDZZM0TdKKoAjjGL2emQ2UNEXSA5Lk7ifcvVHMyUg9OZJyzSxHUn9Je8WcjBTg7uskNbRb3dkc/HVJD3vU7ySdbmZnJSRQhCbMxMAwSbvbLO8J1gEpxcyGSxovaYOkwe6+N9hUK2lwsuIC4nSnpBsltQTLZ0pqdPdIsMzcjFRwrqQ6SQ8Fl8Xcb2anijkZKcTdP5R0u6TfK5oQOCCpUszJSF2dzcEcB6YBbj4ItGFmeZJWSvobdz/YdptHH+HBYzzQa5nZDEn73L0y2bEAn1GOpPMl/dLdx0s6onaXDTAno7cLrr/+uqKJrqGSTtWnT80GUhJzcPrJCbGuDyWd3Wa5KFgHpAQz66NoUuBRd18VrP7YzM5y973BKVH7khchENOXJF1hZpdL6ifpNEWv0z7dzHKCv1AxNyMV7JG0x903BMsrFE0MMCcjlVwi6X/dvU6SzGyVovM0czJSVWdzMMeB3VRbW5s9derUYkmqr6/vk5WV5fn5+RFJ2rx587Z+/fp1mXxZvXr1gL59+7ZceumlRz5rLGEmBt6SdJ6ZnavoQLha0twQ6wd6THAd9gOStrn7HW02PS3pO5JuC/59KgnhAXFx959J+pkkmdlUSX/r7vPM7AlJ31T03i+MY/R67l5rZrvNrNjdqyV9RdLW4Ic5Gani95K+YGb9JX2i6DjeKGmNmJORmjr7Xvy0pB+a2WOSJkk60OaSg9RiVhFqfTHO4hwyZEjz9u3bt0rSggULhubl5TUvWrTo43irf/XVVwfk5eU1h5EYCO1SgiDr+UNJLyp647Zfu/u7YdUP9LAvSbpW0jQz2xz8XK7oxHepmdUomvm/LZlBAt20UNICM9uh6D0HHkhyPEA8/lrSo2b2tqRxkv5RzMlIIcEZLyskbZL0jqLfu+8TczJSgJktl/RfkorNbI+ZfU+dz8HPSfpA0g5JSyT9VRJCThvr16/vf8EFFxSPGTOmZPLkyeft2rWrjyQtXrx40IgRI8aMGjWqdMaMGZ+rrq4+5eGHHy781a9+NXj06NGlL7zwQt5nadeil4cAAAAAAJA5qqqqdpaXl9f/cUWCzxhoa8GCBUNPPfXU5tWrV5/x7LPP7hg6dGhkyZIlZ7z00ksDn3jiiZ2DBg0au2vXrndyc3O9vr4+u6CgoPlkzzKoqqoqKC8vH97RtjAvJQAAAAAAAN1w/PjxrJqamtxp06aNkqSWlhYVFhY2SVJxcfEns2bNOveKK65onDdvXmPYbZMYAAAAAAAgydxdI0eO/GTz5s3b229bs2ZNzfPPPz/gqaeeGnj77befVV1dHepl+zyuEAAAAACAJOvbt29LQ0NDziuvvHKqJB0/ftw2btzYr7m5We+///4pM2fOPHTPPfd8ePjw4ewDBw5kDxgwoPnQoUPZYbRNYgAAAAAAgCTLysrSY4899v5NN91UVFxcXDpmzJjStWvX5kUiEZs7d+65o0aNKi0rKyudP3/+voKCgubZs2c3Pvvss6dz80EAAAAAALrhUzcfTHNd3XyQMwYAAAAAAMhgJAYAAAAAAMhgJAYAAAAAAMhgJAYAAAAAAJmopaWlxZIdRCIE/WzpbDuJAQAAAABAJtpSV1c3MN2TAy0tLVZXVzdQ0pbOyuQkMB4AAAAAAHqFSCQyv7a29v7a2toypfcfzVskbYlEIvM7K8DjCgEAAAAAyGDpnBUBAAAAAAAxkBgAAAAAACCDkRgAAAAAACCDkRgAAAAAACCDkRgAAAAAACCD/R90/Uz47Uok2QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "((#60) [56,0,83,35,86,31,57,84,58,63...],\n",
       " (#20) [23,47,5,71,11,67,18,65,82,30...],\n",
       " (#20) [72,1,46,37,60,20,22,53,38,66...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = L([0] * 50 + [1] * 25 + [2] * 15 + [3] * 10)\n",
    "splits = get_splits(y, valid_size=.2, test_size=.2)\n",
    "test_eq(np.mean(y[splits[0]])==np.mean(y[splits[1]])==np.mean(y[splits[2]]), True)\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABAYAAABTCAYAAAAMVgWOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAARrklEQVR4nO3df3TV9X3H8dc7P0yCQTQmEEN0sSAhISXQINSWIqWVVSt2iPgD1HYrdce1a2e6ij3rsQ7Z5nY8m9t0bUUtOB3+APyFv60IqCuTMK4iEIMOCjaRpEn4IQK5yXt/3G960phfhJvc3Hufj3NyuN/v93Pfn/fV7/mc3Hc+n8/X3F0AAAAAACA5pcQ6AQAAAAAAEDsUBgAAAAAASGIUBgAAAAAASGIUBgAAAAAASGIUBgAAAAAASGIUBgAAAAAASGIUBgAAccvMXjOzRcHrhWb20knEKjIzN7O04Ph5M/tmlPL8kplVdzjebWZfjUbsIN67ZjYzWvEAAEByoTAAAIgpM5tuZm+a2QEzazSzN8zs/BON4+4Pu/vsDnHdzMb2Ny93v9jdV/TWri/9uPtGdy/uby6d+ltuZks7xZ/g7q9FIz4AAEg+abFOAACQvMzsNElrJd0o6TFJp0j6kqRjscwrmswszd3Dsc4DAACgO8wYAADE0jhJcveV7t7q7p+4+0vu/rYkmdm3ghkEdwczCnaa2Ve6ChS0fT14vSE4HTKzw2Z2VRftU83sTjNrMLMPJH290/WOyxTGmtn6IIcGM3u0u37MbKaZ7TOzxWZWJ+mX7ec6pXC+mW03syYz+6WZZXb+HB1y8SCHGyQtlHRz0N8zwfXfL00wswwzu8vMfhv83GVmGcG19tx+aGb7zazWzP601/9LAAAgoVEYAADE0nuSWs1shZldbGZndNFmmqT3JeVK+qmkNWaW01NQd58RvCx392x3f7SLZt+RdKmkyZKmSLqih5C3S3pJ0hmSCiX9ey/95EvKkfRHkm7oJuZCSX8saYwiBZKf9PSZgv7ulfSwpH8K+pvTRbO/kfR5SZMklUua2il2vqQRkkZL+rake7r57w4AAJIEhQEAQMy4+0FJ0yW5pGWS6s3saTMb1aHZfkl3uXtL8MW7Wp3+ut9PVwZx97p7o6R/6KFtiyJf8gvc/ai7v95DW0lqk/RTdz/m7p900+buDn3/naRrTvQDdGOhpCXuvt/d6yX9raTrOlxvCa63uPtzkg5Lisr+BwAAID5RGAAAxJS773D3b7l7oaQySQWS7urQ5EN39w7He4I2J6tA0t5OcbtzsyST9D/BEwD+rJfY9e5+tJc2nfuOxmdSEKfjZ+kc+3ed9jw4Iik7Sn0DAIA4RGEAADBkuPtOScsVKRC0G21m1uH4HEm/jUJ3tZLO7hS3u7zq3P077l4g6c8l/UcvTyLwHq6169x3+2f6WNKw9gtmln+CsX+ryOyGrmIDAAB8CoUBAEDMmNn4YCO8wuD4bEWm1P+6Q7ORkr5vZulmNl9SiaTn+hD+I0mf6eH6Y0HcwmCN/S095Dm/PUdJTYp8OW/rYz/d+W7Qd44i+wK0708QkjTBzCYFGxLe1ul9vfW3UtJPzCzPzHIl3SrpoX7kBwAAkgSFAQBALB1SZHPBTWb2sSIFgW2SftihzSZJ50lqUGQt/hXu/rs+xL5N0gozazazK7u4vkzSi4p8Ed8iaU0Psc4Pcjws6WlJP3D3D/rYT3f+S5ENDT9QZHPFpZLk7u9JWiLpFUk1kjrvZ3C/pNKgvye7iLtU0mZJb0t6J/hsS08gLwAAkGTsD5dtAgAwdJjZtyQtcvfpsc4FAAAgUTFjAAAAAACAJEZhAAAAAACAJMZSAgAAAAAAkhgzBgAAAAAASGIUBgAAAAAASGJpAxHULNelooEIDQAAktCwkh2xTgGIipIdR2KdAnDSqqQGd8+LdR6IngEpDESKApsHJjQAAEg6Jf9ZEesUgKjYPGVLrFMATppJe2KdA6KLpQQAAAAAACQxCgMAAAAAACQxCgMAAAAAACSxAdpjAAAAAACAoauqqmpkWlrafZLKlNh/NG+TtC0cDi+qqKjY31UDCgMAAAAAgKSTlpZ2X35+fkleXl5TSkqKxzqfgdLW1mb19fWldXV190m6rKs2iVwVAQAAAACgO2V5eXkHE7koIEkpKSmel5d3QJGZEV23GcR8AAAAAAAYKlISvSjQLvic3X7/ZykBAAAAAACDrK6uLnXmzJnFktTQ0JCekpLiOTk5YUnaunXrjszMzG6LFhs2bBj2wAMPnLl8+fK90cil18KAmT0g6VJJ+92926kHAAAAAADEKzNVRDOeu6p6up6fn9+6c+fO7ZJUWVlZkJ2d3bpkyZKP2q+3tLQoPT29y/fOmDHjyIwZM45EK9e+LCVYLulr0eoQAAAAAAB82rx584oWLFhwzsSJE8ffeOONhevWrRs2adKk8SUlJaWTJ08eHwqFMiRp7dq1w7/85S+PlSJFhfnz5xdNnTq1uLCw8LNLly4deaL99jpjwN03mFnRCX8iAAAAAABwQmpra0/ZsmXLzrS0NDU2Nqa89dZbO9PT0/Xkk08Ov/nmmwtffPHF9zu/Z9euXZlvvvlmdXNzc2pJSUnZj370o/qMjIw+758QtT0GzOwGSTdEjs6JVlgAAAAAAJLG5Zdf3pSWFvmq3tjYmHrVVVedu3v37kwz85aWFuvqPbNnz27OysryrKyscE5OTsu+ffvSxowZ09LXPqP2VAJ3v9fdp7j7FCkvWmEBAAAAAEga2dnZbe2vFy9ePPrCCy88VFNT8+4zzzyz6/jx411+h+84OyA1NVXhcLjLAkJ3eFwhAAAAAABD0MGDB1MLCwuPS9IvfvGL3IHqh8IAAAAAAABD0OLFi+tuu+22wpKSktJwODxg/Zh7z/sRmNlKSTMl5Ur6SNJP3f3+nt8zxaXN0coRAAAkuYrNUX2CFBAzm6dsiXUKwEkzqSqyhDy+hUKh3eXl5Q2xzmOwhEKh3PLy8qKurvXlqQTXRD0jAAAAAAAwJLCUAAAAAACAJEZhAAAAAACAJEZhAAAAAACAJEZhAAAAAACAJEZhAAAAAACAJEZhAAAAAACAQTZt2rRxq1evPq3juSVLloxcuHDhOV21nzp1avGGDRuGSdKFF144tqGhIbVzm8rKyoJbb7111Inm0uvjCgEAAAAASHQVWyoqohmv6nNVVT1dnz9/fuPKlStz5s2bd7D93OrVq3PuuOOOfb3FXr9+/a5o5NiOGQMAAAAAAAyy6667runVV18dcfToUZOk6urqU/bv35/+0EMP5ZSVlZWMHTt2wk033VTQ1XtHjx792dra2jRJWrx4cX5RUVFZRUVFcU1NTUZ/chmgGQNVhyWrHpjYwKDJldQQ6ySAKOBeRtyrmsJ9jMRgjMlIDMWxTiARjBo1qrW8vPzjVatWjbj22mubV6xYkTNnzpym22+/vXbUqFGt4XBYX/jCF4o3bdqUNW3atE+6irFx48ZhTzzxRM4777yzvaWlRZMmTSqdPHnykRPNZaCWElS7+5QBig0MCjPbzH2MRMC9jETAfYxEwb2MRGBmm2OdQ6K48sorGx999NEzrr322uY1a9bkLFu2bPeKFStyli9fnhsOh62+vj49FApldlcYWLduXfYll1zSPHz48DZJmj17dnN/8mApAQAAAAAAMbBgwYLmN95447TXX3992NGjR1Py8vLCd99996j169e/9957722fNWvWgaNHjw7493YKAwAAAAAAxMCIESPaLrjggkOLFi0qmjt3bmNTU1NqVlZWW05OTuvevXvTXnvttRE9vX/WrFmHn3vuudMPHz5sTU1NKS+//PLp/cljoJYS3DtAcYHBxH2MRMG9jETAfYxEwb2MRMB9HEVXX3114/XXXz9m5cqVH0yePPloWVnZkTFjxpSdddZZxysqKg739N7p06cfmTt3bmNZWdmEM888s2XixIkf9ycHc/f+ZQ8AAAAAQJwKhUK7y8vLk2Yz0FAolFteXl7U1TWWEgAAAAAAkMSiWhgws6+ZWbWZ7TKzW6IZGxhIZna2ma0zs+1m9q6Z/SA4n2NmL5tZTfDvGbHOFeiNmaWa2f+a2drg+Fwz2xSMzY+a2SmxzhHojZmdbmarzGynme0wswsYkxFvzOym4PeKbWa20swyGZMRD8zsATPbb2bbOpzrcgy2iH8L7um3zexzscsc/RW1woCZpUq6R9LFkkolXWNmpdGKDwywsKQfunuppM9L+m5w/94i6Vfufp6kXwXHwFD3A0k7Ohz/o6R/cfexkpokfTsmWQEn5l8lveDu4yWVK3JPMyYjbpjZaEnflzTF3cskpUq6WozJiA/LJX2t07nuxuCLJZ0X/Nwg6WeDlCOiKJozBqZK2uXuH7j7cUmPSPpGFOMDA8bda919S/D6kCK/gI5W5B5eETRbIelPYpIg0EdmVijp65LuC45N0ixJq4Im3McY8sxshKQZku6XJHc/7u7NYkxG/EmTlGVmaZKGSaoVYzLigLtvkNTY6XR3Y/A3JD3oEb+WdLqZnTUoiSJqolkYGC1pb4fjfcE5IK6YWZGkyZI2SRrl7rXBpTpJo2KVF9BHd0m6WVJbcHympGZ3DwfHjM2IB+dKqpf0y2BZzH1mdqoYkxFH3P1DSXdK+o0iBYEDkqrEmIz41d0YzPfABMDmg0AHZpYtabWkv3L3gx2veeQRHjzGA0OWmV0qab+7V8U6F+AkpUn6nKSfuftkSR+r07IBxmQMdcH6628oUugqkHSqPj01G4hLjMGJJy2KsT6UdHaH48LgHBAXzCxdkaLAw+6+Jjj9kZmd5e61wZSo/bHLEOjVFyVdZmaXSMqUdJoi67RPN7O04C9UjM2IB/sk7XP3TcHxKkUKA4zJiCdflfR/7l4vSWa2RpFxmjEZ8aq7MZjvgf1UV1eXOnPmzGJJamhoSE9JSfGcnJywJG3dunVHZmZmj8WXtWvXDs/IyGi76KKLPj7ZXKJZGHhL0nlmdq4iN8LVkhZEMT4wYIJ12PdL2uHu/9zh0tOSvinpjuDfp2KQHtAn7v5jST+WJDObKemv3X2hmT0u6QpF9n7hPsaQ5+51ZrbXzIrdvVrSVyRtD34YkxEvfiPp82Y2TNInitzHmyWtE2My4lN3vxc/Lel7ZvaIpGmSDnRYchBfzCqiGq+XWZz5+fmtO3fu3C5JlZWVBdnZ2a1Lliz5qK/hX3311eHZ2dmt0SgMRG0pQVD1/J6kFxXZuO0xd383WvGBAfZFSddJmmVmW4OfSxQZ+C4ysxpFKv93xDJJoJ8WS6o0s12K7Dlwf4zzAfriLyU9bGZvS5ok6e/FmIw4Esx4WSVpi6R3FPm9+14xJiMOmNlKSf8tqdjM9pnZt9X9GPycpA8k7ZK0TNJfxCDlhLFx48Zh559/fvGECRNKpk+fft6ePXvSJWnp0qUjx4wZM2HcuHGll1566Weqq6tPefDBB/N+/vOfjxo/fnzpCy+8kH0y/VpkeQgAAAAAAMkjFArtLi8vb/j9iUGeMdBRZWVlwamnntq6du3aM5599tldBQUF4WXLlp3x0ksvjXj88cd3jxw5cuKePXveycrK8oaGhtTc3NzWE51lEAqFcsvLy4u6uhbNpQQAAAAAAKAfjh07llJTU5M1a9ascZLU1tamvLy8FkkqLi7+ZO7cuededtllzQsXLmyOdt8UBgAAAAAAiDF319ixYz/ZunXrzs7X1q1bV/P8888Pf+qpp0bceeedZ1VXV0d12T6PKwQAAAAAIMYyMjLaGhsb01555ZVTJenYsWO2efPmzNbWVr3//vunzJkz59A999zz4eHDh1MPHDiQOnz48NZDhw6lRqNvCgMAAAAAAMRYSkqKHnnkkfdvueWWwuLi4tIJEyaUrl+/PjscDtuCBQvOHTduXGlZWVnpokWL9ufm5rbOmzev+dlnnz2dzQcBAAAAAOiHT20+mOB62nyQGQMAAAAAACQxCgMAAAAAACQxCgMAAAAAACQxCgMAAAAAgGTU1tbWZrFOYjAEn7Otu+sUBgAAAAAAyWhbfX39iEQvDrS1tVl9ff0ISdu6a5M2iPkAAAAAADAkhMPhRXV1dffV1dWVKbH/aN4maVs4HF7UXQMeVwgAAAAAQBJL5KoIAAAAAADoBYUBAAAAAACSGIUBAAAAAACSGIUBAAAAAACSGIUBAAAAAACS2P8DUkaad7sjsA4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "((#60) [0,1,2,3,4,5,6,7,8,9...],\n",
       " (#20) [60,61,62,63,64,65,66,67,68,69...],\n",
       " (#20) [80,81,82,83,84,85,86,87,88,89...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = L([0] * 50 + [1] * 25 + [2] * 15 + [3] * 10)\n",
    "splits = get_splits(y, n_splits=1, valid_size=.2, test_size=.2, shuffle=False)\n",
    "# test_eq(splits[0] + splits[1] + splits[2], np.arange(100))\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABAYAAABTCAYAAAAMVgWOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAS/ElEQVR4nO3df3RU9ZnH8c+TBEIgCMQEMMQuFiQkpAQMQm1ZpFTZasEupagFbbtb6h633XalW7Fne6yL7K67x+O6rm5bUQuuLlqB+gN/WxFQt6yEJYpADLpQUCJJQ/gpmEme/WMuPdmYZIZwM5PJvF/n5JB773ee73NnvnznzpN775i7CwAAAAAApKeMZCcAAAAAAACSh8IAAAAAAABpjMIAAAAAAABpjMIAAAAAAABpjMIAAAAAAABpjMIAAAAAAABpjMIAACBlmdkrZrYw+H2Bmb1wBrFGmpmbWVaw/KyZfTOkPP/YzKpbLe82s0vCiB3Ee9vMpocVDwAApBcKAwCApDKzqWb2upkdMrMGM3vNzC483Tju/rC7z2wV181sdFfzcvfL3H1FrHbx9OPuG929uKu5tOlvuZktbRN/nLu/EkZ8AACQfrKSnQAAIH2Z2VmS1kq6XtKvJPWV9MeSTiYzrzCZWZa7R5KdBwAAQEc4YwAAkExjJMndV7p7s7t/5O4vuPubkmRm3wrOILg7OKNgp5l9sb1AQdtXg983BKurzOyomV3VTvtMM7vdzOrN7D1JX26zvfVlCqPNbH2QQ72ZPdpRP2Y23cz2mdliM6uV9MtT69qkcKGZbTezg2b2SzPr13Y/WuXiQQ7XSVog6cagv6eC7X+4NMHMss3sTjP7IPi508yyg22ncvuhmR0ws/1m9mcxXyUAANCrURgAACTTO5KazWyFmV1mZkPaaTNF0ruS8iX9VNIaM8vrLKi7Twt+LXf3XHd/tJ1m35E0S9JESZMkfa2TkLdKekHSEElFkv4tRj/DJeVJ+iNJ13UQc4GkP5E0StECyU8626egv3slPSzpn4P+ZrfT7G8lfVbSBEnlkia3iT1c0iBJIyR9W9I9HTzvAAAgTVAYAAAkjbsfljRVkktaJqnOzJ40s2Gtmh2QdKe7NwUfvKvV5q/7XXRlEHevuzdI+sdO2jYp+iG/0N1PuPurnbSVpBZJP3X3k+7+UQdt7m7V999L+vrp7kAHFkha4u4H3L1O0t9JurbV9qZge5O7PyPpqKRQ7n8AAABSE4UBAEBSufsOd/+WuxdJKpNUKOnOVk3ed3dvtbwnaHOmCiXtbRO3IzdKMkn/HXwDwJ/HiF3n7iditGnbdxj7pCBO631pG/v3be55cFxSbkh9AwCAFERhAADQY7j7TknLFS0QnDLCzKzV8qckfRBCd/slndsmbkd51br7d9y9UNJfSPr3GN9E4J1sO6Vt36f26Zik/qc2mNnw04z9gaJnN7QXGwAA4BMoDAAAksbMxgY3wisKls9V9JT637ZqNlTS982sj5nNk1Qi6Zk4wn8o6dOdbP9VELcouMb+pk7ynHcqR0kHFf1w3hJnPx35btB3nqL3BTh1f4IqSePMbEJwQ8Jb2jwuVn8rJf3EzArMLF/SzZIe6kJ+AAAgTVAYAAAk0xFFby64ycyOKVoQ2Cbph63abJJ0vqR6Ra/F/5q7/z6O2LdIWmFmjWZ2ZTvbl0l6XtEP4lskrekk1oVBjkclPSnpB+7+Xpz9dOQ/Fb2h4XuK3lxxqSS5+zuSlkh6SVKNpLb3M7hfUmnQ3+PtxF0qabOkNyW9Fezb0tPICwAApBn7/5dtAgDQc5jZtyQtdPepyc4FAACgt+KMAQAAAAAA0hiFAQAAAAAA0hiXEgAAAAAAkMY4YwAAAAAAgDRGYQAAAAAAgDSW1S1BB2d5dmF2p22O7yjpjq4/oX/Jjphtwsolnr5KdhyP2aZSFTHbVKgylDhh5byjpH+n2+N5juPZp3iEtd/xiGe/whqDiXx+whpfiRLWc5zI1yqs568nvVY9KZcw9bT3kUSO5TD6Cet9LxX/f/Y0iRzLscTzOsQ6tpBS8xguLD3p9UxFiToGjjdO6s07lfXuXpDsLBCebrnHwIDSAV7yH2M7bVM5KZwPObFUbI79nyysXOLpa/OkLTHbmGK/Ji4LJU5YOU/afEGn2+N5juPZp3iEtd/xiGe/whqDiXx+whpfiRLWc5zI1yqs568nvVY9KZcw9bT3kUSO5TD6Cet9LxX/f/Y0iRzLscTzOsQ6tpBS8xguLD3p9UxFiToGjjdO6s07Vunuk5KdBcLDpQQAAAAAAKQxCgMAAAAAAKQxCgMAAAAAAKSxbrn5IAAAAAAAPVllZeXQrKys+ySVqXf/0bxF0rZIJLKwoqLiQHsNKAwAAAAAANJOVlbWfcOHDy8pKCg4mJGRkWp3gIxbS0uL1dXVldbW1t4n6Yr22vTmqggAAAAAAB0pKygoONybiwKSlJGR4QUFBYcUPTOi/TYJzAcAAAAAgJ4io7cXBU4J9rPDz/9cSgAAAAAAQILV1tZmTp8+vViS6uvr+2RkZHheXl5EkrZu3bqjX79+HRYtNmzY0P+BBx44e/ny5XvDyCVmYcDMHpA0S9IBd+/w1AMAAAAAAFKVmSrCjOeuys62Dx8+vHnnzp3bJWnRokWFubm5zUuWLPnw1Pampib16dOn3cdOmzbt+LRp046HlWs8lxIsl/SlsDoEAAAAAACfNHfu3JHz58//1Pjx48def/31RevWres/YcKEsSUlJaUTJ04cW1VVlS1Ja9euHfiFL3xhtBQtKsybN2/k5MmTi4uKij6zdOnSoafbb8wzBtx9g5mNPO09AgAAAAAAp2X//v19t2zZsjMrK0sNDQ0Zb7zxxs4+ffro8ccfH3jjjTcWPf/88++2fcyuXbv6vf7669WNjY2ZJSUlZT/60Y/qsrOz475/Qmj3GDCz6yRdJ0l9h/cNKywAAAAAAGnjq1/96sGsrOhH9YaGhsyrrrrqvN27d/czM29qarL2HjNz5szGnJwcz8nJieTl5TXt27cva9SoUU3x9hnatxK4+73uPsndJ2UN4Z6GAAAAAACcrtzc3JZTvy9evHjExRdffKSmpubtp556atfHH3/c7mf41mcHZGZmKhKJtFtA6AhfVwgAAAAAQA90+PDhzKKioo8l6Re/+EV+d/VDYQAAAAAAgB5o8eLFtbfccktRSUlJaSQS6bZ+4vm6wpWSpkvKN7N9kn7q7vd3W0YAAAAAACRYrK8X7E533HHHB+2tv+SSS47t3r1726nlu+666wNJmjVr1pFZs2Ydae+xNTU1b59u//F8K8HXTzcoAAAAAABIDVxKAAAAAABAGqMwAAAAAABAGqMwAAAAAABAGqMwAAAAAABAGqMwAAAAAABAGqMwAAAAAABAgk2ZMmXM6tWrz2q9bsmSJUMXLFjwqfbaT548uXjDhg39Jeniiy8eXV9fn9m2zaJFiwpvvvnmYaebS8yvKwQAAAAAoLer2FJREWa8ygsqKzvbPm/evIaVK1fmzZ079/CpdatXr8677bbb9sWKvX79+l1h5HgKZwwAAAAAAJBg11577cGXX3550IkTJ0ySqqur+x44cKDPQw89lFdWVlYyevTocTfccENhe48dMWLEZ/bv358lSYsXLx4+cuTIsoqKiuKamprsruTSLWcMHN9x/GjlpC3Vnbey7uj6EyonxdMqnFzi6Su+nmK3CitOaDlP2nLGUcIbEeHst6R8SfWJ6atnPT9hja9ECes5TuxrFc7zF2dfcYzlM5dq4yZePe19JJFjOYx+Qny/CmVO7q3jNB6JHMuh9BLz2CLuSDElciwrruOL2HrS65mKEncM3GvnneJkJ9AbDBs2rLm8vPzYqlWrBl1zzTWNK1asyJs9e/bBW2+9df+wYcOaI5GIPve5zxVv2rQpZ8qUKR+1F2Pjxo39f/3rX+e99dZb25uamjRhwoTSiRMnHj/dXLrrUoJqd4/voxfQQ5nZZsYxegPGMnoDxjF6C8YyegMz25zsHHqLK6+8suHRRx8dcs011zSuWbMmb9myZbtXrFiRt3z58vxIJGJ1dXV9qqqq+nVUGFi3bl3u5Zdf3jhw4MAWSZo5c2ZjV/LgUgIAAAAAAJJg/vz5ja+99tpZr776av8TJ05kFBQURO6+++5h69evf+edd97ZPmPGjEMnTpzo9s/tFAYAAAAAAEiCQYMGtVx00UVHFi5cOHLOnDkNBw8ezMzJyWnJy8tr3rt3b9Yrr7wyqLPHz5gx4+gzzzwz+OjRo3bw4MGMF198cXBX8uiuSwnu7aa4QCIxjtFbMJbRGzCO0VswltEbMI5DdPXVVzd84xvfGLVy5cr3Jk6ceKKsrOz4qFGjys4555yPKyoqjnb22KlTpx6fM2dOQ1lZ2bizzz67afz48ce6koO5e9eyBwAAAAAgRVVVVe0uLy/v9hs09xRVVVX55eXlI9vbxqUEAAAAAACksVALA2b2JTOrNrNdZnZTmLGB7mRm55rZOjPbbmZvm9kPgvV5ZvaimdUE/w5Jdq5ALGaWaWb/Y2Zrg+XzzGxTMDc/amZ9k50jEIuZDTazVWa208x2mNlFzMlINWZ2Q3Bcsc3MVppZP+ZkpAIze8DMDpjZtlbr2p2DLequYEy/aWYXJC9zdFVohQEzy5R0j6TLJJVK+rqZlYYVH+hmEUk/dPdSSZ+V9N1g/N4k6Tfufr6k3wTLQE/3A0k7Wi3/k6R/cffRkg5K+nZSsgJOz79Kes7dx0oqV3RMMycjZZjZCEnflzTJ3cskZUq6WszJSA3LJX2pzbqO5uDLJJ0f/Fwn6WcJyhEhCvOMgcmSdrn7e+7+saRHJH0lxPhAt3H3/e6+Jfj9iKIHoCMUHcMrgmYrJP1pUhIE4mRmRZK+LOm+YNkkzZC0KmjCOEaPZ2aDJE2TdL8kufvH7t4o5mSknixJOWaWJam/pP1iTkYKcPcNkhrarO5oDv6KpAc96reSBpvZOQlJFKEJszAwQtLeVsv7gnVASjGzkZImStokaZi77w821Uoalqy8gDjdKelGSS3B8tmSGt09EiwzNyMVnCepTtIvg8ti7jOzAWJORgpx9/cl3S7pd4oWBA5JqhRzMlJXR3MwnwN7AW4+CLRiZrmSVkv6a3c/3HqbR7/Cg6/xQI9lZrMkHXD3ymTnApyhLEkXSPqZu0+UdExtLhtgTkZPF1x//RVFC12Fkgbok6dmAymJObj3yQox1vuSzm21XBSsA1KCmfVRtCjwsLuvCVZ/aGbnuPv+4JSoA8nLEIjp85KuMLPLJfWTdJai12kPNrOs4C9UzM1IBfsk7XP3TcHyKkULA8zJSCWXSPpfd6+TJDNbo+g8zZyMVNXRHMznwC6qra3NnD59erEk1dfX98nIyPC8vLyIJG3dunVHv379Oi2+rF27dmB2dnbLpZdeeuxMcwmzMPCGpPPN7DxFB8LVkuaHGB/oNsF12PdL2uHud7Ta9KSkb0q6Lfj3iSSkB8TF3X8s6ceSZGbTJf2Nuy8ws8ckfU3Re78wjtHjuXutme01s2J3r5b0RUnbgx/mZKSK30n6rJn1l/SRouN4s6R1Yk5GaurouPhJSd8zs0ckTZF0qNUlB6nFrCLUeDHO4hw+fHjzzp07t0vSokWLCnNzc5uXLFnyYbzhX3755YG5ubnNYRQGQruUIKh6fk/S84reuO1X7v52WPGBbvZ5SddKmmFmW4OfyxWd+C41sxpFK/+3JTNJoIsWS1pkZrsUvefA/UnOB4jHX0l62MzelDRB0j+IORkpJDjjZZWkLZLeUvS4+14xJyMFmNlKSf8lqdjM9pnZt9XxHPyMpPck7ZK0TNJfJiHlXmPjxo39L7zwwuJx48aVTJ069fw9e/b0kaSlS5cOHTVq1LgxY8aUzpo169PV1dV9H3zwwYKf//znw8aOHVv63HPP5Z5Jvxa9PAQAAAAAgPRRVVW1u7y8vP4PKxJ8xkBrixYtKhwwYEDz2rVrhzz99NO7CgsLI8uWLRvywgsvDHrsscd2Dx06dPyePXveysnJ8fr6+sz8/Pzm0z3LoKqqKr+8vHxke9vCvJQAAAAAAAB0wcmTJzNqampyZsyYMUaSWlpaVFBQ0CRJxcXFH82ZM+e8K664onHBggWNYfdNYQAAAAAAgCRzd40ePfqjrVu37my7bd26dTXPPvvswCeeeGLQ7bfffk51dXWol+3zdYUAAAAAACRZdnZ2S0NDQ9ZLL700QJJOnjxpmzdv7tfc3Kx333237+zZs4/cc8897x89ejTz0KFDmQMHDmw+cuRIZhh9UxgAAAAAACDJMjIy9Mgjj7x70003FRUXF5eOGzeudP369bmRSMTmz59/3pgxY0rLyspKFy5ceCA/P7957ty5jU8//fRgbj4IAAAAAEAXfOLmg71cZzcf5IwBAAAAAADSGIUBAAAAAADSGIUBAAAAAADSGIUBAAAAAEA6amlpabFkJ5EIwX62dLSdwgAAAAAAIB1tq6urG9TbiwMtLS1WV1c3SNK2jtpkJTAfAAAAAAB6hEgksrC2tva+2traMvXuP5q3SNoWiUQWdtSArysEAAAAACCN9eaqCAAAAAAAiIHCAAAAAAAAaYzCAAAAAAAAaYzCAAAAAAAAaYzCAAAAAAAAaez/AJk2VMQdjsZtAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "splits = get_splits(np.random.randint(0,5,100), valid_size=0.213, test_size=17)\n",
    "test_eq(len(splits[1]), 21)\n",
    "test_eq(len(splits[2]), 17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x36 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "((#12) [3,89,71,40,37,34,96,90,42,47...],\n",
       " (#21) [33,92,73,21,72,97,38,27,1,6...],\n",
       " (#17) [67,31,10,79,56,12,74,66,2,41...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splits = get_splits(np.random.randint(0,5,100), valid_size=0.213, test_size=17, train_size=.2)\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def get_predefined_splits(*xs):\n",
    "    '''xs is a list with X_train, X_valid, ...'''\n",
    "    splits_ = []\n",
    "    start = 0\n",
    "    for x in xs: \n",
    "        splits_.append(L(list(np.arange(start, start + len(x)))))\n",
    "        start += len(x)\n",
    "    return tuple(splits_)\n",
    "\n",
    "def combine_split_data(xs, ys=None):\n",
    "    '''xs is a list with X_train, X_valid, .... ys is None or a list with y_train, y_valid, .... '''\n",
    "    xs = [to3d(x) for x in xs]\n",
    "    splits = get_predefined_splits(*xs)\n",
    "    if ys is None: return concat(*xs), None, splits\n",
    "    else: return concat(*xs), concat(*ys), splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def get_splits_len(splits):\n",
    "    _len = []\n",
    "    for split in splits: \n",
    "        if isinstance(split[0], (list, L, tuple)):  _len.append([len(s) for s in split])\n",
    "        else: _len.append(len(split))\n",
    "    return _len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train, X_valid, y_valid = np.random.rand(3,3,4), np.random.randint(0,2,3), np.random.rand(2,3,4), np.random.randint(0,2,2)\n",
    "X, y, splits = combine_split_data([X_train, X_valid], [y_train, y_valid])\n",
    "test_eq(X_train, X[splits[0]])\n",
    "test_eq(X_valid, X[splits[1]])\n",
    "test_type(X_train, X)\n",
    "test_type(y_train, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train, X_valid, y_valid = np.random.rand(3,4), np.random.randint(0,2,3), np.random.rand(2,4), np.random.randint(0,2,2)\n",
    "X, y, splits = combine_split_data([X_train, X_valid], [y_train, y_valid])\n",
    "test_eq(X_train[:, None], X[splits[0]])\n",
    "test_eq(X_valid[:, None], X[splits[1]])\n",
    "test_type(X_train, X)\n",
    "test_type(y_train, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "from tsai.imports import create_scripts\n",
    "from tsai.export import get_nb_name\n",
    "nb_name = get_nb_name()\n",
    "create_scripts(nb_name);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
